Permalink
Cannot retrieve contributors at this time
| /* | |
| * Smuxi - Smart MUltipleXed Irc | |
| * | |
| * Copyright (c) 2005-2015 Mirco Bauer <meebey@meebey.net> | |
| * | |
| * Full GPL License: <http://www.gnu.org/licenses/gpl.txt> | |
| * | |
| * This program is free software; you can redistribute it and/or modify | |
| * it under the terms of the GNU General Public License as published by | |
| * the Free Software Foundation; either version 2 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * This program is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| * GNU General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU General Public License | |
| * along with this program; if not, write to the Free Software | |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| */ | |
| using System; | |
| using System.IO; | |
| using System.Net; | |
| using System.Linq; | |
| using System.Text; | |
| using System.Text.RegularExpressions; | |
| using System.Collections; | |
| using System.Collections.Generic; | |
| using System.Runtime.Remoting; | |
| using System.Threading; | |
| using Smuxi.Common; | |
| namespace Smuxi.Engine | |
| { | |
| public class Session : PermanentRemoteObject, IFrontendUI | |
| { | |
| #if LOG4NET | |
| private static readonly log4net.ILog f_Logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); | |
| #endif | |
| private static readonly string _LibraryTextDomain = "smuxi-engine"; | |
| public static CertificateValidator CertificateValidator { get; private set; } | |
| private int _Version = 0; | |
| private IDictionary<string, FrontendManager> _FrontendManagers; | |
| private IList<IProtocolManager> _ProtocolManagers; | |
| private List<ChatModel> _Chats; | |
| private SessionChatModel _SessionChat; | |
| private Config _Config; | |
| private string _Username; | |
| private ProtocolManagerFactory _ProtocolManagerFactory; | |
| private UserConfig _UserConfig; | |
| private FilterListController _FilterListController; | |
| private ICollection<FilterModel> _Filters; | |
| Timer NewsFeedTimer { get; set; } | |
| List<string> SeenNewsFeedIds { get; set; } | |
| DateTime NewsFeedLastModified { get; set; } | |
| TimeSpan NewsFeedUpdateInterval { get; set; } | |
| TimeSpan NewsFeedRetryInterval { get; set; } | |
| bool IsFirstNewsFeedEntry { get; set; } | |
| internal MessageBuilderSettings MessageBuilderSettings { get; private set; } | |
| public event EventHandler<GroupChatPersonAddedEventArgs> GroupChatPersonAdded; | |
| public event EventHandler<GroupChatPersonRemovedEventArgs> GroupChatPersonRemoved; | |
| public event EventHandler<GroupChatPersonUpdatedEventArgs> GroupChatPersonUpdated; | |
| public event EventHandler<EventMessageEventArgs> EventMessage; | |
| public IList<IProtocolManager> ProtocolManagers { | |
| get { | |
| return _ProtocolManagers; | |
| } | |
| } | |
| public IProtocolManager FirstProtocolManager { | |
| get { | |
| lock (_ProtocolManagers) { | |
| if (_ProtocolManagers.Count == 0) { | |
| return null; | |
| } else { | |
| return _ProtocolManagers[0]; | |
| } | |
| } | |
| } | |
| } | |
| public IList<ChatModel> Chats { | |
| get { | |
| return _Chats; | |
| } | |
| } | |
| public SessionChatModel SessionChat { | |
| get { | |
| return _SessionChat; | |
| } | |
| } | |
| public int Version { | |
| get { | |
| return _Version; | |
| } | |
| } | |
| public Config Config { | |
| get { | |
| return _Config; | |
| } | |
| } | |
| public UserConfig UserConfig { | |
| get { | |
| return _UserConfig; | |
| } | |
| } | |
| public string Username { | |
| get { | |
| return _Username; | |
| } | |
| } | |
| public bool IsLocal { | |
| get { | |
| return _Username == "local"; | |
| } | |
| } | |
| internal ICollection<FilterModel> Filters { | |
| get { | |
| return _Filters; | |
| } | |
| set { | |
| _Filters = value; | |
| } | |
| } | |
| static Session() | |
| { | |
| CertificateValidator = new CertificateValidator(); | |
| } | |
| public Session(Config config, ProtocolManagerFactory protocolManagerFactory, | |
| string username) | |
| { | |
| Trace.Call(config, protocolManagerFactory, username); | |
| if (config == null) { | |
| throw new ArgumentNullException("config"); | |
| } | |
| if (protocolManagerFactory == null) { | |
| throw new ArgumentNullException("protocolManagerFactory"); | |
| } | |
| if (username == null) { | |
| throw new ArgumentNullException("username"); | |
| } | |
| _Config = config; | |
| _ProtocolManagerFactory = protocolManagerFactory; | |
| _Username = username; | |
| _FrontendManagers = new Dictionary<string, FrontendManager>(); | |
| _ProtocolManagers = new List<IProtocolManager>(); | |
| _UserConfig = new UserConfig(config, username); | |
| _UserConfig.Changed += OnUserConfigChanged; | |
| _FilterListController = new FilterListController(_UserConfig); | |
| _Filters = _FilterListController.GetFilterList().Values; | |
| MessageBuilderSettings = new MessageBuilderSettings(); | |
| MessageBuilderSettings.ApplyConfig(_UserConfig); | |
| _Chats = new List<ChatModel>(); | |
| InitSessionChat(); | |
| SeenNewsFeedIds = new List<string>(); | |
| NewsFeedUpdateInterval = TimeSpan.FromHours(12); | |
| NewsFeedRetryInterval = TimeSpan.FromMinutes(5); | |
| IsFirstNewsFeedEntry = true; | |
| NewsFeedTimer = new Timer(delegate { UpdateNewsFeed(); }, null, | |
| TimeSpan.Zero, NewsFeedUpdateInterval); | |
| } | |
| public void ExecuteOnStartupCommands() | |
| { | |
| foreach (string command in (string[]) _UserConfig["OnStartupCommands"]) { | |
| if (command.Length == 0) { | |
| continue; | |
| } | |
| var cd = new CommandModel(null, _SessionChat, | |
| (string)_UserConfig["Interface/Entry/CommandCharacter"], | |
| command); | |
| var handled = Command(cd); | |
| if (!handled) { | |
| #if LOG4NET | |
| f_Logger.Error("ExecuteOnStartupCommands(): command unknown: " + command); | |
| #endif | |
| var builder = CreateMessageBuilder(). | |
| AppendEventPrefix(). | |
| AppendErrorText("unknown command: {0}", command); | |
| AddMessageToChat(_SessionChat, builder.ToMessage(), true); | |
| } | |
| } | |
| } | |
| public void ProcessAutoConnect() | |
| { | |
| var serverCon = new ServerListController(_UserConfig); | |
| IList<ServerModel> servers = serverCon.GetServerList(); | |
| foreach (ServerModel server in servers) { | |
| if (!server.OnStartupConnect) { | |
| continue; | |
| } | |
| var msg = String.Format( | |
| _("Automatically connecting to {0}..."), | |
| String.Format("{0}/{1} ({2}:{3})", server.Protocol, | |
| server.Network, server.Hostname, server.Port) | |
| ); | |
| #if LOG4NET | |
| f_Logger.Info(msg); | |
| #endif | |
| var builder = CreateMessageBuilder(). | |
| AppendEventPrefix(). | |
| AppendText(msg); | |
| AddMessageToChat(_SessionChat, builder.ToMessage(), true); | |
| var srv = server; | |
| // run connects in background threads as they block | |
| ThreadPool.QueueUserWorkItem(delegate { | |
| bool isError = false; | |
| try { | |
| IProtocolManager protocolManager = Connect(srv, null); | |
| // if the connect command was correct, we should be | |
| // able to get the chat model | |
| if (protocolManager.Chat == null) { | |
| isError = true; | |
| } | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("ProcessAutoConnect(): Exception during "+ | |
| "automatic connect: ", ex); | |
| #endif | |
| isError = true; | |
| } | |
| if (isError) { | |
| builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendErrorText( | |
| _("Automatic connect to {0} failed!"), | |
| srv.Hostname + ":" + srv.Port | |
| ); | |
| AddMessageToChat(_SessionChat, builder.ToMessage(), true); | |
| } | |
| }); | |
| } | |
| } | |
| public IProtocolManager NextProtocolManager(IProtocolManager currentProtocolManager) | |
| { | |
| lock (_ProtocolManagers) { | |
| if (_ProtocolManagers.Count == 0) { | |
| return null; | |
| } | |
| int pos = 0; | |
| if (currentProtocolManager != null) { | |
| pos = _ProtocolManagers.IndexOf(currentProtocolManager); | |
| } | |
| if (pos < _ProtocolManagers.Count - 1) { | |
| pos++; | |
| } else { | |
| pos = 0; | |
| } | |
| return _ProtocolManagers[pos]; | |
| } | |
| } | |
| protected MessageBuilder CreateMessageBuilder() | |
| { | |
| var builder = new MessageBuilder(); | |
| // copy settings so the caller can override settings without | |
| // changing the settings of the complete session | |
| builder.Settings = new MessageBuilderSettings(MessageBuilderSettings); | |
| return builder; | |
| } | |
| public void RegisterFrontendUI(IFrontendUI ui) | |
| { | |
| Trace.Call(ui); | |
| if (ui == null) { | |
| throw new ArgumentNullException("ui"); | |
| } | |
| string uri = GetUri(ui); | |
| #if LOG4NET | |
| f_Logger.Debug("Registering UI with URI: " + uri); | |
| #endif | |
| // add the FrontendManager to the hashtable with an unique .NET remoting identifier | |
| FrontendManager fm = new FrontendManager(this, ui); | |
| lock (_FrontendManagers) { | |
| _FrontendManagers[uri] = fm; | |
| } | |
| } | |
| internal void DeregisterFrontendManager(FrontendManager fm) | |
| { | |
| Trace.Call(fm); | |
| if (fm == null) { | |
| throw new ArgumentNullException("fm"); | |
| } | |
| string key = null; | |
| lock (_FrontendManagers) { | |
| foreach (KeyValuePair<string, FrontendManager> kv in _FrontendManagers) { | |
| if (kv.Value == fm) { | |
| key = kv.Key; | |
| break; | |
| } | |
| } | |
| } | |
| if (key == null) { | |
| #if LOG4NET | |
| f_Logger.Debug("DeregisterFrontendManager(fm): could not find " + | |
| "frontend manager (probably already cleanly " + | |
| " deregistered), ignoring..."); | |
| #endif | |
| return; | |
| } | |
| lock (_FrontendManagers) { | |
| _FrontendManagers.Remove(key); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("DeregisterFrontendUI(fm): disposing FrontendManager"); | |
| #endif | |
| fm.Dispose(); | |
| CheckPresenceStatus(); | |
| } | |
| public void DeregisterFrontendUI(IFrontendUI ui) | |
| { | |
| Trace.Call(ui); | |
| if (ui == null) { | |
| throw new ArgumentNullException("ui"); | |
| } | |
| string uri = GetUri(ui); | |
| #if LOG4NET | |
| f_Logger.Debug("DeregisterFrontendUI(ui): deregistering UI with URI: "+uri); | |
| #endif | |
| FrontendManager manager; | |
| lock (_FrontendManagers) { | |
| _FrontendManagers.TryGetValue(uri, out manager); | |
| _FrontendManagers.Remove(uri); | |
| } | |
| if (manager == null) { | |
| #if LOG4NET | |
| f_Logger.Error("DeregisterFrontendUI(ui): can't dispose as FrontendManager not found with URI: " + uri); | |
| #endif | |
| } else { | |
| #if LOG4NET | |
| f_Logger.Debug("DeregisterFrontendUI(ui): disposing FrontendManager with URI: " + uri); | |
| #endif | |
| manager.Dispose(); | |
| } | |
| CheckPresenceStatus(); | |
| } | |
| public FrontendManager GetFrontendManager(IFrontendUI ui) | |
| { | |
| Trace.Call(ui); | |
| if (ui == null) { | |
| throw new ArgumentNullException("ui"); | |
| } | |
| lock (_FrontendManagers) { | |
| return _FrontendManagers[GetUri(ui)]; | |
| } | |
| } | |
| private string GetUri(IFrontendUI ui) | |
| { | |
| if (ui == null) { | |
| throw new ArgumentNullException("ui"); | |
| } | |
| if (IsLocal) { | |
| return "local"; | |
| } | |
| return RemotingServices.GetObjectUri((MarshalByRefObject)ui); | |
| } | |
| public static bool IsLocalFrontend(IFrontendUI ui) | |
| { | |
| if (ui == null) { | |
| throw new ArgumentNullException("ui"); | |
| } | |
| return RemotingServices.GetObjectUri((MarshalByRefObject)ui) == null; | |
| } | |
| public ChatModel GetChat(string id, ChatType chatType, IProtocolManager networkManager) | |
| { | |
| if (id == null) { | |
| throw new ArgumentNullException("id"); | |
| } | |
| lock (_Chats) { | |
| foreach (ChatModel chat in _Chats) { | |
| if ((chat.ID.ToLower() == id.ToLower()) && | |
| (chat.ChatType == chatType) && | |
| (chat.ProtocolManager == networkManager)) { | |
| return chat; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| public bool Command(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| bool handled = false; | |
| if (cd.IsCommand) { | |
| switch (cd.Command) { | |
| case "help": | |
| CommandHelp(cd); | |
| if (cd.Chat.ChatType == ChatType.Session) { | |
| handled = true; | |
| } | |
| break; | |
| case "server": | |
| case "connect": | |
| CommandConnect(cd); | |
| handled = true; | |
| break; | |
| case "disconnect": | |
| CommandDisconnect(cd); | |
| handled = true; | |
| break; | |
| case "reconnect": | |
| CommandReconnect(cd); | |
| handled = true; | |
| break; | |
| case "network": | |
| CommandNetwork(cd); | |
| handled = true; | |
| break; | |
| case "config": | |
| CommandConfig(cd); | |
| handled = true; | |
| break; | |
| case "shutdown": | |
| CommandShutdown(cd); | |
| handled = true; | |
| break; | |
| case "echo": | |
| CommandEcho(cd); | |
| handled = true; | |
| break; | |
| default: | |
| var filteredCmd = IOSecurity.GetFilteredPath(cd.Command); | |
| var hooks = new HookRunner("engine", "session", | |
| "command-" + filteredCmd); | |
| var pm = cd.Chat.ProtocolManager; | |
| hooks.Environments.Add(new CommandHookEnvironment(cd)); | |
| hooks.Environments.Add(new ChatHookEnvironment(cd.Chat)); | |
| if (pm != null) { | |
| hooks.Environments.Add(new ProtocolManagerHookEnvironment(pm)); | |
| } | |
| var cmdChar = (string) UserConfig["Interface/Entry/CommandCharacter"]; | |
| hooks.Commands.Add(new SessionHookCommand(this, cd.Chat, cmdChar)); | |
| if (pm != null) { | |
| hooks.Commands.Add(new ProtocolManagerHookCommand(pm, cd.Chat, cmdChar)); | |
| } | |
| // show time | |
| hooks.Init(); | |
| if (hooks.HasHooks) { | |
| hooks.Run(); | |
| handled = true; | |
| } | |
| break; | |
| } | |
| } else { | |
| // normal text | |
| if (cd.Chat.ChatType == ChatType.Session && | |
| cd.FrontendManager != null && | |
| cd.FrontendManager.CurrentProtocolManager == null) { | |
| _NotConnected(cd); | |
| handled = true; | |
| } | |
| } | |
| return handled; | |
| } | |
| public void CommandHelp(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| var builder = CreateMessageBuilder(); | |
| // TRANSLATOR: this line is used as a label / category for a | |
| // list of commands below | |
| builder.AppendHeader(_("Engine Commands")); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| string[] help = { | |
| "connect/server protocol [protocol-parameters]", | |
| "connect/server network", | |
| "disconnect [server]", | |
| "network list", | |
| "network close [network]", | |
| "network switch [network]", | |
| "config (save|load|list)", | |
| "config get key", | |
| "config set key=value", | |
| "config remove key", | |
| "shutdown" | |
| }; | |
| foreach (string line in help) { | |
| builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendText(line); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| } | |
| } | |
| public void CommandConnect(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| FrontendManager fm = cd.FrontendManager; | |
| MessageBuilder builder = null; | |
| string protocol = null; | |
| ServerModel server = null; | |
| // first lookup by network name | |
| if (cd.DataArray.Length == 2) { | |
| var network = cd.Parameter; | |
| var serverSettings = new ServerListController(UserConfig); | |
| server = serverSettings.GetServerByNetwork(network); | |
| if (server == null) { | |
| // HACK: simply assume the user meant irc if not specified | |
| // as Smuxi is still primarly an IRC client | |
| protocol = "irc"; | |
| string cmd = String.Format("{0}connect irc {1}", | |
| cd.CommandCharacter, cd.Parameter); | |
| cd = new CommandModel(fm, cd.Chat, cd.CommandCharacter, cmd); | |
| } | |
| } else if (cd.DataArray.Length >= 3) { | |
| protocol = cd.DataArray[1]; | |
| } else { | |
| _NotEnoughParameters(cd); | |
| return; | |
| } | |
| IProtocolManager protocolManager = null; | |
| // TODO: detect matching protocol managers, how to parse host and port | |
| // though in a protocol neutral ? | |
| /* | |
| foreach (IProtocolManager nm in _ProtocolManagers) { | |
| if (nm.Host == server && | |
| nm.Port == port) { | |
| // reuse network manager | |
| if (nm.IsConnected) { | |
| fm.AddTextToCurrentChat("-!- " + String.Format( | |
| _("Already connected to: {0}:{1}"), server, port)); | |
| return; | |
| } | |
| networkManager = nm; | |
| break; | |
| } | |
| } | |
| */ | |
| if (protocolManager == null && server == null) { | |
| try { | |
| protocolManager = CreateProtocolManager(protocol); | |
| lock (_ProtocolManagers) { | |
| _ProtocolManagers.Add(protocolManager); | |
| } | |
| } catch (ArgumentException ex) { | |
| if (ex.ParamName != "protocol") { | |
| throw; | |
| } | |
| // this is an unknown protocol error | |
| builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendErrorText(ex.Message); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| return; | |
| } | |
| } | |
| // HACK: this is hacky as the Command parser of the protocol manager | |
| // will pass this command to it's connect method only if cd was | |
| // constructed correctly beginning with /connect | |
| // So make sure it's like it needs to be! | |
| if (cd.Command != "connect") { | |
| string cmd = String.Format("{0}connect {1}", | |
| cd.CommandCharacter, | |
| String.Join(" ", cd.DataArray, 1, | |
| cd.DataArray.Length - 1)); | |
| cd = new CommandModel(fm, cd.Chat, cd.CommandCharacter, cmd); | |
| } | |
| // run in background so it can't block the command queue | |
| ThreadPool.QueueUserWorkItem(delegate { | |
| try { | |
| if (protocolManager == null && server != null) { | |
| protocolManager = Connect(server, fm); | |
| } else { | |
| protocolManager.Command(cd); | |
| } | |
| // set this as current protocol manager | |
| // but only if there was none set (we might be on a chat for example) | |
| // or if this is the neutral "smuxi" tab | |
| if (fm.CurrentProtocolManager == null || | |
| (fm.CurrentChat != null && fm.CurrentChat.ChatType == ChatType.Session)) { | |
| fm.CurrentProtocolManager = protocolManager; | |
| fm.UpdateNetworkStatus(); | |
| } | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("CommandConnect(): ", ex); | |
| #endif | |
| builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendErrorText(_("Connect failed!")); | |
| fm.AddMessageToChat(cd.Chat, builder.ToMessage()); | |
| } | |
| }); | |
| } | |
| public void CommandDisconnect(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| FrontendManager fm = cd.FrontendManager; | |
| IProtocolManager victim = null; | |
| if (cd.DataArray.Length >= 2) { | |
| string server = cd.DataArray[1]; | |
| victim = GetProtocolManagerByHost(server); | |
| if (victim == null) { | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendErrorText( | |
| _("Disconnect failed - could not find server: {0}"), | |
| server | |
| ); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| return; | |
| } | |
| } else { | |
| victim = cd.Chat.ProtocolManager; | |
| } | |
| if (victim == null) { | |
| return; | |
| } | |
| victim.Disconnect(fm); | |
| victim.Dispose(); | |
| lock (_ProtocolManagers) { | |
| _ProtocolManagers.Remove(victim); | |
| } | |
| } | |
| public void CommandReconnect(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| var pm = cd.Chat.ProtocolManager; | |
| if (pm == null) { | |
| return; | |
| } | |
| ThreadPool.QueueUserWorkItem(delegate { | |
| try { | |
| pm.Reconnect(cd.FrontendManager); | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("CommandReconnect(): ", ex); | |
| #endif | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendErrorText(_("Reconnect failed!")); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| } | |
| }); | |
| } | |
| public void CommandConfig(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| if (cd.DataArray.Length < 2) { | |
| _NotEnoughParameters(cd); | |
| return; | |
| } | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| var action = cd.DataArray[1].ToLower(); | |
| switch (action) { | |
| case "load": | |
| _Config.Load(); | |
| builder.AppendText(_("Configuration reloaded")); | |
| break; | |
| case "save": | |
| _Config.Save(); | |
| builder.AppendText(_("Configuration saved")); | |
| break; | |
| case "get": | |
| case "list": | |
| string key = null; | |
| if (action == "get" && cd.DataArray.Length >= 3) { | |
| key = cd.DataArray[2]; | |
| } | |
| foreach (var entry in _UserConfig.OrderBy(kvp => kvp.Key)) { | |
| if (key != null && | |
| entry.Key.IndexOf(key, StringComparison.InvariantCultureIgnoreCase) == -1) { | |
| continue; | |
| } | |
| builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendText("{0} = {1}", entry.Key, entry.Value); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| } | |
| return; | |
| case "set": | |
| if (cd.DataArray.Length < 3) { | |
| _NotEnoughParameters(cd); | |
| return; | |
| } | |
| var setParam = String.Join(" ", cd.DataArray.Skip(2).ToArray()); | |
| if (!setParam.Contains("=")) { | |
| builder.AppendErrorText( | |
| _("Invalid key/value format.") | |
| ); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| return; | |
| } | |
| var setKey = setParam.Split('=')[0].Trim(); | |
| var setValue = String.Join( | |
| "=", setParam.Split('=').Skip(1).ToArray() | |
| ).Trim(); | |
| object oldValue = _UserConfig[setKey]; | |
| if (oldValue == null && setKey.StartsWith("MessagePatterns/")) { | |
| var id = setKey.Split('/')[1]; | |
| var parsedId = Int32.Parse(id); | |
| var msgPatternSettings = new MessagePatternListController(_UserConfig); | |
| var pattern = msgPatternSettings.Get(parsedId); | |
| if (pattern == null) { | |
| // pattern does not exist, create it with default values | |
| pattern = new MessagePatternModel(parsedId); | |
| msgPatternSettings.Add(pattern, parsedId); | |
| oldValue = _UserConfig[setKey]; | |
| } | |
| } | |
| if (oldValue == null) { | |
| builder.AppendErrorText( | |
| _("Invalid config key: '{0}'"), | |
| setKey | |
| ); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| return; | |
| } | |
| try { | |
| object newValue = Convert.ChangeType(setValue, oldValue.GetType()); | |
| _UserConfig[setKey] = newValue; | |
| builder.AppendText("{0} = {1}", setKey, newValue.ToString()); | |
| if (setKey.StartsWith("MessagePatterns/")) { | |
| MessageBuilderSettings.ApplyConfig(UserConfig); | |
| } | |
| } catch (InvalidCastException) { | |
| builder.AppendErrorText( | |
| _("Could not convert config value: '{0}' to type: {1}"), | |
| setValue, | |
| oldValue.GetType().Name | |
| ); | |
| } catch (FormatException) { | |
| builder.AppendErrorText( | |
| _("Could not convert config value: '{0}' to type: {1}"), | |
| setValue, | |
| oldValue.GetType().Name | |
| ); | |
| } | |
| break; | |
| case "remove": { | |
| if (cd.DataArray.Length < 3) { | |
| _NotEnoughParameters(cd); | |
| return; | |
| } | |
| var removeParam = cd.DataArray[2]; | |
| if (!removeParam.StartsWith("MessagePatterns/")) { | |
| builder.AppendErrorText( | |
| _("Invalid config remove key: '{0}'. Valid remove " + | |
| "keys: MessagePatterns/{{ID}}."), | |
| removeParam | |
| ); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| return; | |
| } | |
| var id = removeParam.Split('/')[1]; | |
| var parsedId = Int32.Parse(id); | |
| var patternController = new MessagePatternListController(_UserConfig); | |
| var pattern = patternController.Get(parsedId); | |
| if (pattern == null) { | |
| builder.AppendErrorText( | |
| _("Message pattern with ID: '{0}' does not exist."), | |
| id | |
| ); | |
| } else { | |
| patternController.Remove(parsedId); | |
| MessageBuilderSettings.ApplyConfig(UserConfig); | |
| builder.AppendText( | |
| _("Message pattern with ID: '{0}' removed."), | |
| id | |
| ); | |
| } | |
| break; | |
| } | |
| default: | |
| builder.AppendErrorText( | |
| _("Invalid parameter for config; use load, save, get or set.") | |
| ); | |
| break; | |
| } | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| } | |
| public void CommandShutdown(CommandModel cmd) | |
| { | |
| Trace.Call(cmd); | |
| #if LOG4NET | |
| f_Logger.Info("Shutting down..."); | |
| #endif | |
| var frontendMgr = cmd != null ? cmd.FrontendManager : null; | |
| Shutdown(true, frontendMgr); | |
| if (IsLocal) { | |
| // allow the frontend to cleanly terminate | |
| return; | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("Terminating process..."); | |
| #endif | |
| Environment.Exit(0); | |
| } | |
| public void CommandEcho(CommandModel cmd) | |
| { | |
| Trace.Call(cmd); | |
| if (cmd == null) { | |
| throw new ArgumentNullException("cmd"); | |
| } | |
| var msg = CreateMessageBuilder(). | |
| AppendEventPrefix(). | |
| AppendText(cmd.Parameter). | |
| ToMessage(); | |
| if (cmd.FrontendManager == null) { | |
| AddMessageToChat(cmd.Chat, msg, true); | |
| } else { | |
| cmd.FrontendManager.AddMessageToChat(cmd.Chat, msg); | |
| } | |
| } | |
| public void CommandNetwork(CommandModel cd) | |
| { | |
| Trace.Call(cd); | |
| if (cd == null) { | |
| throw new ArgumentNullException("cd"); | |
| } | |
| if (cd.DataArray.Length == 1) { | |
| // no parameter given, fallback to list | |
| _CommandNetworkList(cd); | |
| return; | |
| } | |
| if (cd.DataArray.Length >= 2) { | |
| switch (cd.DataArray[1].ToLower()) { | |
| case "list": | |
| _CommandNetworkList(cd); | |
| break; | |
| case "switch": | |
| _CommandNetworkSwitch(cd); | |
| break; | |
| case "close": | |
| _CommandNetworkClose(cd); | |
| break; | |
| default: | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendText( | |
| _("Invalid parameter for network; use list, " + | |
| "switch, or close") | |
| ); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| break; | |
| } | |
| } else { | |
| _NotEnoughParameters(cd); | |
| } | |
| } | |
| private void _CommandNetworkList(CommandModel cmd) | |
| { | |
| var servers = new ServerListController(UserConfig); | |
| var availableNetworks = servers.GetNetworks(); | |
| var connectedNetworks = new List<IProtocolManager>(); | |
| lock (_ProtocolManagers) { | |
| foreach (IProtocolManager pm in _ProtocolManagers) { | |
| if (pm.IsConnected) { | |
| connectedNetworks.Add(pm); | |
| if (!String.IsNullOrEmpty(pm.NetworkID)) { | |
| availableNetworks.Remove(pm.NetworkID); | |
| } | |
| } | |
| } | |
| } | |
| var msg = CreateMessageBuilder(); | |
| // TRANSLATOR: this line is used as a label / category for a | |
| // list of networks below | |
| msg.AppendHeader(_("Connected Networks")); | |
| AddMessageToFrontend(cmd, msg.ToMessage()); | |
| foreach (var network in connectedNetworks) { | |
| msg = CreateMessageBuilder(); | |
| msg.AppendEventPrefix(); | |
| msg.AppendText("{0}: {1} ", _("Network"), network.NetworkID); | |
| msg.AppendText("{0}: {1} ", _("Protocol"), network.Protocol); | |
| msg.AppendText("{0}: {1} ", _("Host"), network.Host); | |
| msg.AppendText("{0}: {1}", _("Port"), network.Port); | |
| AddMessageToFrontend(cmd, msg.ToMessage()); | |
| } | |
| if (connectedNetworks.Count == 0) { | |
| msg = CreateMessageBuilder(); | |
| // TRANSLATOR: no connected networks | |
| msg.AppendEventPrefix().AppendText("<{0}>", _("None")); | |
| AddMessageToFrontend(cmd, msg.ToMessage()); | |
| } | |
| msg = CreateMessageBuilder(); | |
| // TRANSLATOR: this line is used as a label / category for a | |
| // list of networks below | |
| msg.AppendHeader(_("Available Networks")); | |
| AddMessageToFrontend(cmd, msg.ToMessage()); | |
| foreach (var network in availableNetworks) { | |
| if (network == null || network.Trim().Length == 0) { | |
| continue; | |
| } | |
| msg = CreateMessageBuilder(); | |
| msg.AppendEventPrefix(); | |
| msg.AppendText("{0}: {1}", _("Network"), network); | |
| AddMessageToFrontend(cmd, msg.ToMessage()); | |
| } | |
| if (availableNetworks.Count == 0) { | |
| msg = CreateMessageBuilder(); | |
| // TRANSLATOR: no available networks | |
| msg.AppendEventPrefix().AppendText("<{0}>", _("None")); | |
| AddMessageToFrontend(cmd, msg.ToMessage()); | |
| } | |
| } | |
| private void _CommandNetworkClose(CommandModel cd) | |
| { | |
| IProtocolManager pm = null; | |
| if (cd.DataArray.Length >= 3) { | |
| // named protocol manager | |
| string network = cd.DataArray[2]; | |
| pm = GetProtocolManagerByNetwork(network); | |
| if (pm == null) { | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendText(_("Network close failed - could not " + | |
| "find network: {0}"), network); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| return; | |
| } | |
| } else if (cd.DataArray.Length >= 2) { | |
| // network manager of chat | |
| pm = cd.Chat.ProtocolManager; | |
| } | |
| if (pm == null) { | |
| return; | |
| } | |
| // disconnect in background as could be blocking | |
| ThreadPool.QueueUserWorkItem(delegate { | |
| try { | |
| pm.Disconnect(cd.FrontendManager); | |
| pm.Dispose(); | |
| // Dispose() takes care of removing the chat from session (frontends) | |
| lock (_ProtocolManagers) { | |
| _ProtocolManagers.Remove(pm); | |
| } | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("_CommandNetworkClose(): Exception", ex); | |
| #endif | |
| } | |
| }); | |
| } | |
| private void _CommandNetworkSwitch(CommandModel cd) | |
| { | |
| FrontendManager fm = cd.FrontendManager; | |
| if (fm == null) { | |
| _NotEnoughParameters(cd); | |
| return; | |
| } | |
| if (cd.DataArray.Length >= 3) { | |
| // named network manager | |
| string network = cd.DataArray[2]; | |
| var pm = GetProtocolManagerByNetwork(network); | |
| if (pm == null) { | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendText(_("Network switch failed - could not " + | |
| "find network: {0}"), network); | |
| fm.AddMessageToChat(cd.Chat, builder.ToMessage()); | |
| return; | |
| } | |
| fm.CurrentProtocolManager = pm; | |
| fm.UpdateNetworkStatus(); | |
| } else if (cd.DataArray.Length >= 2) { | |
| // next network manager | |
| fm.NextProtocolManager(); | |
| } else { | |
| _NotEnoughParameters(cd); | |
| } | |
| } | |
| private void _NotConnected(CommandModel cd) | |
| { | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendText(_("Not connected to any network")); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| } | |
| private void _NotEnoughParameters(CommandModel cd) | |
| { | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendText(_("Not enough parameters for {0} command"), | |
| cd.Command); | |
| AddMessageToFrontend(cd, builder.ToMessage()); | |
| } | |
| public void UpdateNetworkStatus() | |
| { | |
| Trace.Call(); | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.UpdateNetworkStatus(); | |
| } | |
| } | |
| } | |
| public T CreateChat<T>(string id, | |
| string name, | |
| IProtocolManager protocolManager) | |
| where T : ChatModel | |
| { | |
| Trace.Call(id, name, protocolManager); | |
| T chat; | |
| Type chatType = typeof(T); | |
| if (chatType == typeof(SessionChatModel)) { | |
| chat = (T) Activator.CreateInstance(chatType, id, name); | |
| } else if (chatType == typeof(PersonChatModel)) { | |
| throw new NotSupportedException( | |
| "PersonModel is not supported, use " + | |
| "Session.CreatePersionChat() instead" | |
| ); | |
| } else { | |
| chat = (T) Activator.CreateInstance(chatType, | |
| id, name, protocolManager); | |
| } | |
| chat.ApplyConfig(UserConfig); | |
| return chat; | |
| } | |
| public PersonChatModel CreatePersonChat(PersonModel person, | |
| IProtocolManager protocolManager) | |
| { | |
| Trace.Call(person, protocolManager); | |
| if (person == null) { | |
| throw new ArgumentNullException("person"); | |
| } | |
| return CreatePersonChat(person, person.ID, person.IdentityName, | |
| protocolManager); | |
| } | |
| public PersonChatModel CreatePersonChat(PersonModel person, | |
| string id, string name, | |
| IProtocolManager protocolManager) | |
| { | |
| Trace.Call(person, id, name, protocolManager); | |
| var chat = new PersonChatModel(person, id, name, protocolManager); | |
| chat.ApplyConfig(UserConfig); | |
| return chat; | |
| } | |
| public void AddChat(ChatModel chat) | |
| { | |
| Trace.Call(chat); | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| chat.Position = GetSortedChatPosition(chat); | |
| lock (_Chats) { | |
| _Chats.Add(chat); | |
| if (chat.Position == -1) { | |
| chat.Position = _Chats.IndexOf(chat); | |
| } else { | |
| MoveChat(chat, chat.Position); | |
| } | |
| } | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.AddChat(chat); | |
| } | |
| } | |
| } | |
| public void RemoveChat(ChatModel chat) | |
| { | |
| Trace.Call(chat); | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| lock (_Chats) { | |
| if (!_Chats.Remove(chat)) { | |
| #if LOG4NET | |
| f_Logger.Warn("RemoveChat(): _Chats.Remove(" + chat + ") failed, ignoring..."); | |
| #endif | |
| chat.Close(); | |
| return; | |
| } | |
| chat.Close(); | |
| // refresh chat positions | |
| foreach (var schat in _Chats) { | |
| schat.Position = _Chats.IndexOf(schat); | |
| } | |
| } | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.RemoveChat(chat); | |
| } | |
| } | |
| } | |
| public void EnableChat(ChatModel chat) | |
| { | |
| Trace.Call(chat); | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| chat.IsEnabled = true; | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.EnableChat(chat); | |
| } | |
| } | |
| } | |
| public void DisableChat(ChatModel chat) | |
| { | |
| Trace.Call(chat); | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| chat.IsEnabled = false; | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.DisableChat(chat); | |
| } | |
| } | |
| } | |
| public void SyncChat(ChatModel chat) | |
| { | |
| Trace.Call(chat); | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.SyncChat(chat); | |
| } | |
| } | |
| } | |
| public void MoveChat(ChatModel chat, int newPosition) | |
| { | |
| Trace.Call(chat, newPosition); | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| lock (_Chats) { | |
| _Chats.Remove(chat); | |
| _Chats.Insert(newPosition, chat); | |
| foreach (var schat in _Chats) { | |
| schat.Position = _Chats.IndexOf(schat); | |
| } | |
| } | |
| } | |
| [Obsolete("This method is deprecated, use AddMessageToChat(ChatModel, MessageModel) instead!")] | |
| public void AddTextToChat(ChatModel chat, string text) | |
| { | |
| AddTextToChat(chat, text, false); | |
| } | |
| [Obsolete("This method is deprecated, use AddMessageToChat(ChatModel, MessageModel, bool) instead!")] | |
| public void AddTextToChat(ChatModel chat, string text, bool ignoreFilters) | |
| { | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| if (text == null) { | |
| throw new ArgumentNullException("text"); | |
| } | |
| AddMessageToChat(chat, new MessageModel(text), ignoreFilters); | |
| } | |
| public void AddMessageToChat(ChatModel chat, MessageModel msg) | |
| { | |
| AddMessageToChat(chat, msg, false); | |
| } | |
| public void AddMessageToChat(ChatModel chat, MessageModel msg, | |
| bool ignoreFilters) | |
| { | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| if (msg == null) { | |
| throw new ArgumentNullException("msg"); | |
| } | |
| bool isFiltered = !ignoreFilters && IsFilteredMessage(chat, msg); | |
| LogMessage(chat, msg, isFiltered); | |
| if (isFiltered) { | |
| return; | |
| } | |
| lock (chat.MessageBuffer) { | |
| try { | |
| chat.MessageBuffer.Add(msg); | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| Trace.Call(chat, msg, ignoreFilters); | |
| f_Logger.ErrorFormat( | |
| "AddMessageToChat({0}, {1}, {2}): " + | |
| "chat.MessageBuffer.Add() threw exception:", | |
| chat, msg, ignoreFilters | |
| ); | |
| f_Logger.Error("AddMessageToChat(): ", ex); | |
| #endif | |
| if (chat.MessageBuffer is Db4oMessageBuffer || | |
| chat.MessageBuffer is SqliteMessageBuffer) { | |
| #if LOG4NET | |
| f_Logger.Error( | |
| "AddMessageToChat(): " + | |
| "Falling back to volatile message buffer..." | |
| ); | |
| #endif | |
| chat.ResetMessageBuffer(); | |
| chat.InitMessageBuffer(MessageBufferPersistencyType.Volatile); | |
| var builder = CreateMessageBuilder(); | |
| builder.AppendEventPrefix(); | |
| builder.AppendErrorText( | |
| _("Failed to write to chat history. " + | |
| "Your chat history will not be preserved. " + | |
| "Reason: {0}"), | |
| ex.Message | |
| ); | |
| chat.MessageBuffer.Add(builder.ToMessage()); | |
| chat.MessageBuffer.Add(msg); | |
| } | |
| } | |
| } | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.AddMessageToChat(chat, msg); | |
| } | |
| } | |
| if (msg.MessageType == MessageType.Event) { | |
| // on-event-message | |
| OnEventMessage( | |
| // at this point we no longer know who sent this nor to whom | |
| new EventMessageEventArgs(chat, msg, String.Empty, String.Empty) | |
| ); | |
| } | |
| } | |
| public void AddPersonToGroupChat(GroupChatModel groupChat, PersonModel person) | |
| { | |
| if (groupChat == null) { | |
| throw new ArgumentNullException("groupChat"); | |
| } | |
| if (person == null) { | |
| throw new ArgumentNullException("person"); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("AddPersonToGroupChat() groupChat.Name: "+groupChat.Name+" person.IdentityName: "+person.IdentityName); | |
| #endif | |
| groupChat.UnsafePersons.Add(person.ID, person); | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.AddPersonToGroupChat(groupChat, person); | |
| } | |
| } | |
| OnGroupChatPersonAdded( | |
| new GroupChatPersonAddedEventArgs(groupChat, person) | |
| ); | |
| } | |
| public void UpdatePersonInGroupChat(GroupChatModel groupChat, PersonModel oldPerson, PersonModel newPerson) | |
| { | |
| if (groupChat == null) { | |
| throw new ArgumentNullException("groupChat"); | |
| } | |
| if (oldPerson == null) { | |
| throw new ArgumentNullException("oldPerson"); | |
| } | |
| if (newPerson == null) { | |
| throw new ArgumentNullException("newPerson"); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("UpdatePersonInGroupChat()" + | |
| " groupChat.Name: " + groupChat.Name + | |
| " oldPerson.IdentityName: " + oldPerson.IdentityName + | |
| " newPerson.IdentityName: " + newPerson.IdentityName); | |
| #endif | |
| // FIXME: do we have to lock groupChat.UnsafePersons here? | |
| // probably not, as long as the ProtocolManager who owns this chat | |
| // is only running one thread | |
| groupChat.UnsafePersons.Remove(oldPerson.ID); | |
| groupChat.UnsafePersons.Add(newPerson.ID, newPerson); | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.UpdatePersonInGroupChat(groupChat, oldPerson, newPerson); | |
| } | |
| } | |
| OnGroupChatPersonUpdated( | |
| new GroupChatPersonUpdatedEventArgs(groupChat, oldPerson, newPerson) | |
| ); | |
| } | |
| public void UpdateTopicInGroupChat(GroupChatModel groupChat, MessageModel topic) | |
| { | |
| if (groupChat == null) { | |
| throw new ArgumentNullException("groupChat"); | |
| } | |
| if (topic == null) { | |
| throw new ArgumentNullException("topic"); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("UpdateTopicInGroupChat() groupChat.Name: " + groupChat.Name + " topic: " + topic.ToString()); | |
| #endif | |
| groupChat.Topic = topic; | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.UpdateTopicInGroupChat(groupChat, topic); | |
| } | |
| } | |
| } | |
| public void RemovePersonFromGroupChat(GroupChatModel groupChat, PersonModel person) | |
| { | |
| if (groupChat == null) { | |
| throw new ArgumentNullException("groupChat"); | |
| } | |
| if (person == null) { | |
| throw new ArgumentNullException("person"); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("RemovePersonFromGroupChat() groupChat.Name: " + groupChat.Name + " person.ID: "+person.ID); | |
| #endif | |
| groupChat.UnsafePersons.Remove(person.ID); | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.RemovePersonFromGroupChat(groupChat, person); | |
| } | |
| } | |
| OnGroupChatPersonRemoved( | |
| new GroupChatPersonRemovedEventArgs(groupChat, person) | |
| ); | |
| } | |
| public void SetNetworkStatus(string status) | |
| { | |
| if (status == null) { | |
| throw new ArgumentNullException("status"); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("SetNetworkStatus() status: "+status); | |
| #endif | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.SetNetworkStatus(status); | |
| } | |
| } | |
| } | |
| public void SetStatus(string status) | |
| { | |
| if (status == null) { | |
| throw new ArgumentNullException("status"); | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("SetStatus() status: "+status); | |
| #endif | |
| lock (_FrontendManagers) { | |
| foreach (FrontendManager fm in _FrontendManagers.Values) { | |
| fm.SetStatus(status); | |
| } | |
| } | |
| } | |
| public IList<string> GetSupportedProtocols() | |
| { | |
| return _ProtocolManagerFactory.GetProtocols(); | |
| } | |
| public IProtocolManager Connect(ServerModel server, FrontendManager frontendManager) | |
| { | |
| Trace.Call(server, frontendManager); | |
| if (server == null) { | |
| throw new ArgumentNullException("server"); | |
| } | |
| if (String.IsNullOrEmpty(server.Protocol)) { | |
| throw new ArgumentNullException("server.Protocol"); | |
| } | |
| IProtocolManager protocolManager = CreateProtocolManager( | |
| server.Protocol | |
| ); | |
| lock (_ProtocolManagers) { | |
| _ProtocolManagers.Add(protocolManager); | |
| } | |
| string password = null; | |
| // only pass non-empty passwords to Connect() | |
| if (!String.IsNullOrEmpty(server.Password)) { | |
| password = server.Password; | |
| } | |
| if (server.OnConnectCommands != null && server.OnConnectCommands.Count > 0) { | |
| protocolManager.Connected += delegate { | |
| ThreadPool.QueueUserWorkItem(delegate { | |
| try { | |
| foreach (string command in server.OnConnectCommands) { | |
| if (command.Length == 0) { | |
| continue; | |
| } | |
| try { | |
| var cd = new CommandModel( | |
| frontendManager, | |
| protocolManager.Chat, | |
| (string) _UserConfig["Interface/Entry/CommandCharacter"], | |
| command | |
| ); | |
| protocolManager.Command(cd); | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("Connect(): Command in Connected event: Exception", ex); | |
| #endif | |
| var msg = CreateMessageBuilder(). | |
| AppendErrorText("Command '{0}' failed. Reason: {1} ({2})", | |
| command, ex.Message, ex.GetType()). | |
| ToMessage(); | |
| AddMessageToFrontend (frontendManager, protocolManager.Chat, msg); | |
| } | |
| } | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("Connect(): Connected event: Exception", ex); | |
| #endif | |
| } | |
| }); | |
| }; | |
| } | |
| protocolManager.Connect(frontendManager, server); | |
| if (protocolManager.Chat == null) { | |
| // just in case the ProtocolManager is not setting the | |
| // protocol chat | |
| throw new ApplicationException(_("Connect failed.")); | |
| } | |
| return protocolManager; | |
| } | |
| private IProtocolManager CreateProtocolManager(string protocol) | |
| { | |
| ProtocolManagerInfoModel info = | |
| _ProtocolManagerFactory.GetProtocolManagerInfoByAlias(protocol); | |
| if (info == null) { | |
| if (_ProtocolManagerFactory.ProtocolManagerInfos.Count != 1) { | |
| throw new ArgumentException( | |
| String.Format( | |
| _("No protocol manager found for the protocol: {0}"), | |
| protocol | |
| ), | |
| "protocol" | |
| ); | |
| } | |
| // ok, we forgive the user not passing a valid protocol by | |
| // falling back to the only available protocol | |
| info = _ProtocolManagerFactory.ProtocolManagerInfos[0]; | |
| } | |
| return _ProtocolManagerFactory.CreateProtocolManager(info, this); | |
| } | |
| public void LogMessage(ChatModel chat, MessageModel msg, bool isFiltered) | |
| { | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| if (msg == null) { | |
| throw new ArgumentNullException("msg"); | |
| } | |
| if (!(bool) UserConfig["Logging/Enabled"]) { | |
| return; | |
| } | |
| if (isFiltered && !(bool) UserConfig["Logging/LogFilteredMessages"]) { | |
| return; | |
| } | |
| if (chat.ChatType == ChatType.Session || | |
| chat.ChatType == ChatType.Protocol) { | |
| return; | |
| } | |
| try { | |
| // HACK: twitter retrieves older messages and we don't want to | |
| // re-log those when the twitter connection is re-opened | |
| var protocol = chat.ProtocolManager.Protocol.ToLower(); | |
| if (protocol == "twitter") { | |
| return; | |
| } | |
| // don't log chatstates | |
| switch (msg.MessageType) { | |
| case MessageType.ChatStateComposing: | |
| case MessageType.ChatStatePaused: | |
| case MessageType.ChatStateReset: | |
| return; | |
| } | |
| using (var stream = File.AppendText(chat.LogFile)) { | |
| stream.WriteLine( | |
| String.Format( | |
| "[{0:yyyy-MM-dd HH:mm:ss}] {1}", | |
| msg.TimeStamp.ToLocalTime(), | |
| msg.ToString() | |
| ) | |
| ); | |
| } | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("LogMessage(): logging error", ex); | |
| #endif | |
| } | |
| } | |
| public bool IsFilteredMessage(ChatModel chat, MessageModel msg) | |
| { | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| if (msg == null) { | |
| throw new ArgumentNullException("msg"); | |
| } | |
| return IsFilteredMessage(chat, msg.ToString(), msg.MessageType); | |
| } | |
| public bool IsFilteredMessage(ChatModel chat, string msg, | |
| MessageType msgType) | |
| { | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| if (msg == null) { | |
| throw new ArgumentNullException("msg"); | |
| } | |
| lock (_Filters) { | |
| foreach (var filter in _Filters) { | |
| if (!String.IsNullOrEmpty(filter.Protocol) && | |
| chat.ProtocolManager != null && | |
| filter.Protocol != chat.ProtocolManager.Protocol) { | |
| continue; | |
| } | |
| if (!String.IsNullOrEmpty(filter.NetworkID) && | |
| chat.ProtocolManager != null && | |
| String.Compare(filter.NetworkID, | |
| chat.ProtocolManager.NetworkID, | |
| StringComparison.OrdinalIgnoreCase) != 0) { | |
| continue; | |
| } | |
| if (filter.ChatType.HasValue && | |
| filter.ChatType != chat.ChatType) { | |
| continue; | |
| } | |
| if (!String.IsNullOrEmpty(filter.ChatID) && | |
| !Pattern.IsMatch(chat.ID, filter.ChatID)) { | |
| continue; | |
| } | |
| if (filter.MessageType.HasValue && | |
| filter.MessageType != msgType) { | |
| continue; | |
| } | |
| if (!String.IsNullOrEmpty(filter.MessagePattern)) { | |
| var pattern = filter.MessagePattern; | |
| if (!Pattern.ContainsPatternCharacters(pattern)) { | |
| // use globbing by default | |
| pattern = String.Format("*{0}*", pattern); | |
| } | |
| if (!Pattern.IsMatch(msg, pattern)) { | |
| continue; | |
| } | |
| } | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| public void AddMessageToFrontend(CommandModel cmd, MessageModel msg) | |
| { | |
| if (cmd == null) { | |
| throw new ArgumentNullException("cmd"); | |
| } | |
| AddMessageToFrontend(cmd.FrontendManager, cmd.Chat, msg); | |
| } | |
| public void AddMessageToFrontend(FrontendManager fm, ChatModel chat, MessageModel msg) | |
| { | |
| if (chat == null) { | |
| throw new ArgumentNullException("chat"); | |
| } | |
| if (msg == null) { | |
| throw new ArgumentNullException("msg"); | |
| } | |
| if (fm == null) { | |
| // fallback to session | |
| AddMessageToChat(chat, msg); | |
| } else { | |
| fm.AddMessageToChat(chat, msg); | |
| } | |
| } | |
| void OnUserConfigChanged(object sender, ConfigChangedEventArgs e) | |
| { | |
| if (e.Key.StartsWith("Filters/")) { | |
| #if LOG4NET | |
| f_Logger.Debug("OnUserConfigChanged(): refreshing filters"); | |
| #endif | |
| // referesh filters | |
| // TODO: use a timeout here to only refresh once in 1 second | |
| _Filters = _FilterListController.GetFilterList().Values; | |
| } | |
| if (e.Key == "Interface/Chat/HighlightWords") { | |
| MessageBuilderSettings.ApplyConfig(UserConfig); | |
| } | |
| if (e.Key == "Interface/Notebook/EngineBufferLines") { | |
| lock (_Chats) { | |
| foreach (var chat in _Chats) { | |
| chat.ApplyConfig(UserConfig); | |
| } | |
| } | |
| } | |
| } | |
| public void CheckPresenceStatus() | |
| { | |
| Trace.Call(); | |
| var newStatus = PresenceStatus.Unknown; | |
| var newMessage = String.Empty; | |
| lock (_FrontendManagers) { | |
| if (_FrontendManagers.Count == 0) { | |
| newStatus = PresenceStatus.Away; | |
| newMessage = "away from keyboard"; | |
| } else { | |
| newStatus = PresenceStatus.Online; | |
| } | |
| } | |
| if (newStatus == PresenceStatus.Unknown) { | |
| return; | |
| } | |
| UpdatePresenceStatus(newStatus, newMessage); | |
| } | |
| public void Shutdown() | |
| { | |
| Shutdown(false, null); | |
| } | |
| public void Shutdown(bool clean, FrontendManager frontendManager) | |
| { | |
| Trace.Call(clean, frontendManager); | |
| #if LOG4NET | |
| f_Logger.Debug("Shutdown(): flushing all message buffers"); | |
| #endif | |
| lock (_Chats) { | |
| foreach (var chat in _Chats) { | |
| try { | |
| chat.MessageBuffer.Flush(); | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.ErrorFormat( | |
| "Shutdown(): {0}.MessageBuffer.Flush() " + | |
| "failed, continuing with shutdown...", | |
| chat.ToString() | |
| ); | |
| f_Logger.Error("Shutdown(): Exception", ex); | |
| #endif | |
| } | |
| } | |
| } | |
| if (!clean) { | |
| return; | |
| } | |
| #if LOG4NET | |
| f_Logger.Debug("Shutdown(): disconnecting and disposing all protocol manangers"); | |
| #endif | |
| lock (_ProtocolManagers) { | |
| foreach (var protocolManager in _ProtocolManagers) { | |
| try { | |
| protocolManager.Disconnect(frontendManager); | |
| protocolManager.Dispose(); | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.ErrorFormat( | |
| "Shutdown(): {0}.Disconnect/Dispose() " + | |
| "failed, continuing with shutdown...", | |
| protocolManager.ToString() | |
| ); | |
| f_Logger.Error("Shutdown(): Exception", ex); | |
| #endif | |
| } | |
| } | |
| } | |
| } | |
| void UpdatePresenceStatus(PresenceStatus status, string message) | |
| { | |
| lock (_ProtocolManagers) { | |
| foreach (var manager in _ProtocolManagers) { | |
| manager.SetPresenceStatus(status, message); | |
| } | |
| } | |
| } | |
| IProtocolManager GetProtocolManagerByHost(string network) | |
| { | |
| lock (_ProtocolManagers) { | |
| foreach (var manager in _ProtocolManagers) { | |
| if (String.Compare(manager.Host, network, true) == 0) { | |
| return manager; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| IProtocolManager GetProtocolManagerByNetwork(string network) | |
| { | |
| lock (_ProtocolManagers) { | |
| foreach (var manager in _ProtocolManagers) { | |
| if (String.Compare(manager.NetworkID, network, true) == 0) { | |
| return manager; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| int GetSortedChatPosition(ChatModel chatModel) | |
| { | |
| int position = chatModel.Position; | |
| if (position != -1) { | |
| return position; | |
| } | |
| ChatType type = chatModel.ChatType; | |
| if (type != ChatType.Person && | |
| type != ChatType.Group) { | |
| return position; | |
| } | |
| // new group person and group chats behind their protocol chat | |
| IProtocolManager pm = chatModel.ProtocolManager; | |
| lock (_Chats) { | |
| foreach (var chat in _Chats) { | |
| if (chat.ChatType == ChatType.Protocol && | |
| chat.ProtocolManager == pm) { | |
| position = _Chats.IndexOf(chat) + 1; | |
| break; | |
| } | |
| } | |
| if (position == -1) { | |
| return position; | |
| } | |
| // now find the first chat with a different protocol manager | |
| foreach (var chat in _Chats.Skip(position)) { | |
| if (chat.ProtocolManager != pm) { | |
| return _Chats.IndexOf(chat); | |
| } | |
| } | |
| } | |
| // if there was no next protocol manager, simply append | |
| // the chat way to the end | |
| return -1; | |
| } | |
| void InitSessionChat() | |
| { | |
| _SessionChat = new SessionChatModel("smuxi", "Smuxi"); | |
| _Chats.Add(_SessionChat); | |
| var builder = CreateMessageBuilder(); | |
| var text = builder.CreateText(_("Welcome to Smuxi")); | |
| text.ForegroundColor = new TextColor(255, 0, 0); | |
| text.Bold = true; | |
| builder.AppendText(text); | |
| builder.AppendText(Environment.NewLine); | |
| text = builder.CreateText( | |
| _("Type /help to get a list of available commands.") | |
| ); | |
| text.Bold = true; | |
| builder.AppendText(text); | |
| builder.AppendText(Environment.NewLine); | |
| text = builder.CreateText(_("After you have made a connection " + | |
| "the list of available commands changes. Go to the newly " + | |
| "opened connection tab and use the /help command again to " + | |
| "see the extended command list.")); | |
| text.Bold = true; | |
| builder.AppendText(text); | |
| builder.AppendText(Environment.NewLine); | |
| AddMessageToChat(_SessionChat,builder.ToMessage()); | |
| } | |
| void UpdateNewsFeed() | |
| { | |
| Trace.Call(); | |
| try { | |
| var proxySettings = new ProxySettings(); | |
| proxySettings.ApplyConfig(UserConfig); | |
| var url = "http://news.smuxi.org/feed.php"; | |
| var req = WebRequest.Create(url); | |
| req.Proxy = proxySettings.GetWebProxy(url); | |
| if (req is HttpWebRequest) { | |
| var httpReq = (HttpWebRequest) req; | |
| httpReq.UserAgent = Engine.VersionString; | |
| if (NewsFeedLastModified != DateTime.MinValue) { | |
| httpReq.IfModifiedSince = NewsFeedLastModified; | |
| } | |
| } | |
| var res = req.GetResponse(); | |
| if (res is HttpWebResponse) { | |
| var httpRes = (HttpWebResponse) res; | |
| if (httpRes.StatusCode == HttpStatusCode.NotModified) { | |
| return; | |
| } | |
| NewsFeedLastModified = httpRes.LastModified; | |
| } | |
| var feed = AtomFeed.Load(res.GetResponseStream()); | |
| var sortedEntries = feed.Entry.OrderBy(x => x.Published); | |
| foreach (var entry in sortedEntries) { | |
| if (SeenNewsFeedIds.Contains(entry.Id)) { | |
| continue; | |
| } | |
| SeenNewsFeedIds.Add(entry.Id); | |
| var msg = new FeedMessageBuilder(); | |
| if (IsFirstNewsFeedEntry) { | |
| IsFirstNewsFeedEntry = false; | |
| msg.AppendText("\n"); | |
| msg.AppendHeader("Smuxi News"); | |
| msg.AppendText("\n"); | |
| } | |
| msg.Append(entry); | |
| if (!msg.IsEmpty) { | |
| msg.AppendText("\n"); | |
| AddMessageToChat(SessionChat, msg.ToMessage()); | |
| } | |
| } | |
| } catch (WebException ex) { | |
| switch (ex.Status) { | |
| case WebExceptionStatus.ConnectFailure: | |
| case WebExceptionStatus.ConnectionClosed: | |
| case WebExceptionStatus.Timeout: | |
| case WebExceptionStatus.ReceiveFailure: | |
| case WebExceptionStatus.NameResolutionFailure: | |
| case WebExceptionStatus.ProxyNameResolutionFailure: | |
| #if LOG4NET | |
| f_Logger.Warn( | |
| String.Format( | |
| "UpdateNewsFeed(): Temporarily issue " + | |
| "detected, retrying in {0} min...", | |
| NewsFeedRetryInterval.Minutes | |
| ), | |
| ex | |
| ); | |
| #endif | |
| NewsFeedTimer.Change(NewsFeedRetryInterval, NewsFeedUpdateInterval); | |
| break; | |
| } | |
| } catch (Exception ex) { | |
| #if LOG4NET | |
| f_Logger.Error("UpdateNewsFeed(): Exception, ignored...", ex); | |
| #endif | |
| } | |
| } | |
| protected virtual void OnGroupChatPersonAdded(GroupChatPersonAddedEventArgs e) | |
| { | |
| if (GroupChatPersonAdded != null) { | |
| GroupChatPersonAdded(this, e); | |
| } | |
| var pm = e.GroupChat.ProtocolManager; | |
| var hooks = new HookRunner("engine", "session", "on-group-chat-person-added"); | |
| hooks.Environments.Add(new ChatHookEnvironment(e.GroupChat)); | |
| if (pm != null) { | |
| hooks.Environments.Add(new ProtocolManagerHookEnvironment(pm)); | |
| } | |
| hooks.Environments.Add(new PersonHookEnvironment(e.AddedPerson)); | |
| var cmdChar = (string) UserConfig["Interface/Entry/CommandCharacter"]; | |
| hooks.Commands.Add(new SessionHookCommand(this, e.GroupChat, cmdChar)); | |
| if (pm != null) { | |
| hooks.Commands.Add(new ProtocolManagerHookCommand(pm, e.GroupChat, cmdChar)); | |
| } | |
| // show time | |
| hooks.Init(); | |
| hooks.Run(); | |
| } | |
| protected virtual void OnGroupChatPersonRemoved(GroupChatPersonRemovedEventArgs e) | |
| { | |
| if (GroupChatPersonRemoved != null) { | |
| GroupChatPersonRemoved(this, e); | |
| } | |
| var pm = e.GroupChat.ProtocolManager; | |
| var hooks = new HookRunner("engine", "session", "on-group-chat-person-removed"); | |
| hooks.Environments.Add(new ChatHookEnvironment(e.GroupChat)); | |
| if (pm != null) { | |
| hooks.Environments.Add(new ProtocolManagerHookEnvironment(pm)); | |
| } | |
| hooks.Environments.Add(new PersonHookEnvironment(e.RemovedPerson)); | |
| var cmdChar = (string) UserConfig["Interface/Entry/CommandCharacter"]; | |
| hooks.Commands.Add(new SessionHookCommand(this, e.GroupChat, cmdChar)); | |
| if (pm != null) { | |
| hooks.Commands.Add(new ProtocolManagerHookCommand(pm, e.GroupChat, cmdChar)); | |
| } | |
| // show time | |
| hooks.Init(); | |
| hooks.Run(); | |
| } | |
| protected virtual void OnGroupChatPersonUpdated(GroupChatPersonUpdatedEventArgs e) | |
| { | |
| if (GroupChatPersonUpdated != null) { | |
| GroupChatPersonUpdated(this, e); | |
| } | |
| var pm = e.GroupChat.ProtocolManager; | |
| var hooks = new HookRunner("engine", "session", "on-group-chat-person-updated"); | |
| hooks.Environments.Add(new ChatHookEnvironment(e.GroupChat)); | |
| if (pm != null) { | |
| hooks.Environments.Add(new ProtocolManagerHookEnvironment(pm)); | |
| } | |
| hooks.Environments.Add(new PersonHookEnvironment("OLD_", e.OldPerson)); | |
| hooks.Environments.Add(new PersonHookEnvironment("NEW_", e.NewPerson)); | |
| var cmdChar = (string) UserConfig["Interface/Entry/CommandCharacter"]; | |
| hooks.Commands.Add(new SessionHookCommand(this, e.GroupChat, cmdChar)); | |
| if (pm != null) { | |
| hooks.Commands.Add(new ProtocolManagerHookCommand(pm, e.GroupChat, cmdChar)); | |
| } | |
| // show time | |
| hooks.Init(); | |
| hooks.Run(); | |
| } | |
| protected virtual void OnEventMessage(EventMessageEventArgs e) | |
| { | |
| if (EventMessage != null) { | |
| EventMessage(this, e); | |
| } | |
| var pm = e.Chat.ProtocolManager; | |
| var hooks = new HookRunner("engine", "session", "on-event-message"); | |
| hooks.Environments.Add(new ChatHookEnvironment(e.Chat)); | |
| if (pm != null) { | |
| hooks.Environments.Add(new ProtocolManagerHookEnvironment(pm)); | |
| } | |
| hooks.Environments.Add(new MessageHookEnvironment(e.Message, | |
| e.Sender, | |
| e.Receiver)); | |
| var cmdChar = (string) UserConfig["Interface/Entry/CommandCharacter"]; | |
| hooks.Commands.Add(new SessionHookCommand(this, e.Chat, cmdChar)); | |
| if (pm != null) { | |
| hooks.Commands.Add(new ProtocolManagerHookCommand(pm, e.Chat, cmdChar)); | |
| } | |
| // show time | |
| hooks.Init(); | |
| hooks.Run(); | |
| } | |
| private static string _(string msg) | |
| { | |
| return LibraryCatalog.GetString(msg, _LibraryTextDomain); | |
| } | |
| } | |
| public abstract class GroupChatEventArgs : EventArgs | |
| { | |
| public GroupChatModel GroupChat { get; protected set; } | |
| } | |
| public class GroupChatPersonAddedEventArgs : GroupChatEventArgs | |
| { | |
| public PersonModel AddedPerson { get; private set; } | |
| public GroupChatPersonAddedEventArgs(GroupChatModel groupChat, PersonModel addedPerson) | |
| { | |
| GroupChat = groupChat; | |
| AddedPerson = addedPerson; | |
| } | |
| } | |
| public class GroupChatPersonRemovedEventArgs : GroupChatEventArgs | |
| { | |
| public PersonModel RemovedPerson { get; private set; } | |
| public GroupChatPersonRemovedEventArgs(GroupChatModel groupChat, PersonModel removedPerson) | |
| { | |
| GroupChat = groupChat; | |
| RemovedPerson = removedPerson; | |
| } | |
| } | |
| public class GroupChatPersonUpdatedEventArgs : GroupChatEventArgs | |
| { | |
| public PersonModel OldPerson { get; private set; } | |
| public PersonModel NewPerson { get; private set; } | |
| public GroupChatPersonUpdatedEventArgs(GroupChatModel groupChat, | |
| PersonModel oldPerson, | |
| PersonModel newPerson) | |
| { | |
| GroupChat = groupChat; | |
| OldPerson = oldPerson; | |
| NewPerson = newPerson; | |
| } | |
| } | |
| public class EventMessageEventArgs : EventArgs | |
| { | |
| public ChatModel Chat { get; protected set; } | |
| public MessageModel Message { get; protected set; } | |
| public string Sender { get; protected set; } | |
| public string Receiver { get; protected set; } | |
| public EventMessageEventArgs(ChatModel chat, MessageModel msg, | |
| string sender, string receiver) | |
| { | |
| Chat = chat; | |
| Message = msg; | |
| Sender = sender; | |
| Receiver = receiver; | |
| } | |
| } | |
| } |