root/TwitterIrcGateway/trunk/TwitterIrcGatewayCore/Session.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net.Sockets;
using System.Net;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Web;
using System.Xml;

using TypableMap;
using Misuzilla.Net.Irc;
using Misuzilla.Applications.TwitterIrcGateway.Filter;
using Misuzilla.Applications.TwitterIrcGateway.AddIns;

namespace Misuzilla.Applications.TwitterIrcGateway
{
    public class Session : IDisposable
    {
        private readonly static String ConfigBasePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "Configs");

        private Server _server;
        private TcpClient _tcpClient;
        private StreamWriter _writer;
        private String _clientHost;
        private TwitterService _twitter;
        private TwitterIMService _twitterIm;
        private LinkedList<Int32> _lastStatusIdsFromGateway;
        private Groups _groups;
        private Filters _filter;
        private Config _config;
        private AddInManager _addinManager;

        private List<String> _nickNames = new List<string>();
        private Boolean _isFirstTime = true;

        private TraceListener _traceListener;

        private String _username;
        private String _password;
        private String _nick;
        
        #region Events
        public event EventHandler<MessageReceivedEventArgs> MessageReceived;
        public event EventHandler<SessionStartedEventArgs> SessionStarted;
        public event EventHandler<EventArgs> SessionEnded;
        
        public event EventHandler<EventArgs> ConfigChanged;

        public event EventHandler<EventArgs> AddInsLoadCompleted;

        public event EventHandler<TimelineStatusesEventArgs> PreProcessTimelineStatuses;
        public event EventHandler<TimelineStatusEventArgs> PreProcessTimelineStatus;
        public event EventHandler<TimelineStatusEventArgs> PreFilterProcessTimelineStatus;
        public event EventHandler<TimelineStatusEventArgs> PostFilterProcessTimelineStatus;
        public event EventHandler<TimelineStatusEventArgs> PreSendMessageTimelineStatus;
        public event EventHandler<TimelineStatusEventArgs> PostSendMessageTimelineStatus;
        public event EventHandler<TimelineStatusEventArgs> PostProcessTimelineStatus;
        public event EventHandler<TimelineStatusesEventArgs> PostProcessTimelineStatuses;

        public event EventHandler<StatusUpdateEventArgs> PreSendUpdateStatus;
        #endregion

        private Boolean _requireIMReconnect = false;
        private Int32 _imReconnectCount = 0;

        public Session(Server server, TcpClient tcpClient)
        {
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_USER);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_NICK);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_PASS);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_QUIT);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_PRIVMSG);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_WHOIS);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_INVITE);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_JOIN);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_PART);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_KICK);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_LIST);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_TOPIC);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_MODE);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_TIGIMENABLE);
            MessageReceived += new EventHandler<MessageReceivedEventArgs>(MessageReceived_TIGIMDISABLE);

            _groups = new Groups();
            _filter = new Filters();
            _config = new Config();

            _server = server;
            _tcpClient = tcpClient;
            _lastStatusIdsFromGateway = new LinkedList<int>();
            
            _addinManager = new AddInManager();
        }

        ~Session()
        {
            this.Dispose();
        }

        /// <summary>
        /// 
        /// </summary>
        public TcpClient TcpClient
        {
            get { return _tcpClient; }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public String Nick
        {
            get { return _nick; }
        }
        
        /// <summary>
        /// 
        /// </summary>
        public String ClientHost
        {
            get { return _clientHost; }
        }
        
        /// <summary>
        /// セッションに結びつけられたTwitterへのAPIアクセスのためのサービス
        /// </summary>
        public TwitterService TwitterService
        {
            get { return _twitter; }
        }
        
        /// <summary>
        /// セッションに結びつけられた設定
        /// </summary>
        public Config Config
        {
            get { return _config; }
        }
        
        /// <summary>
        /// セッションが持つグループのコレクション
        /// </summary>
        public Groups Groups
        {
            get { return _groups;  }
        }

        /// <summary>
        /// セッションを開始します。
        /// </summary>
        public void Start()
        {
            CheckDisposed();
            try
            {
                using (NetworkStream stream = _tcpClient.GetStream())
                using (StreamReader sr = new StreamReader(stream, _server.Encoding))
                using (StreamWriter sw = new StreamWriter(stream, _server.Encoding))
                {
                    _writer = sw;

                    String line;
                    while (_tcpClient.Connected && (line = sr.ReadLine()) != null)
                    {
                        try
                        {
                            IRCMessage msg = IRCMessage.CreateMessage(line);
                            OnMessageReceived(msg);
                        }
                        catch (IRCException)
                        {}
                    }
                }
            }
            catch (IOException)
            {}
            catch (NullReferenceException)
            {}
            finally
            {
                OnSessionEnded();
                this.Close();
            }
        }

        #region イベント実行メソッド
        protected virtual void OnMessageReceived(IRCMessage msg)
        {
            FireEvent(MessageReceived, new MessageReceivedEventArgs(msg, _writer, _tcpClient));
        }
        protected virtual void OnSessionStarted(String username)
        {
            LoadConfig();
            OnConfigChanged();
            
            LoadGroups();
            LoadFilters();

            if (!String.IsNullOrEmpty(_config.IMServiceServerName))
            {
                ConnectToIMService(true);
            }

            _addinManager.Load(_server, this);
            FireEvent(AddInsLoadCompleted, EventArgs.Empty);
            
            FireEvent(SessionStarted, new SessionStartedEventArgs(username));
        }
        protected virtual void OnSessionEnded()
        {
            FireEvent(SessionEnded, EventArgs.Empty);
        }
        protected virtual void OnConfigChanged()
        {
            if (ConfigChanged != null)
                ConfigChanged(this, EventArgs.Empty);

            if (_traceListener == null && (_config.EnableTrace || _server.EnableTrace))
            {
                _traceListener = new IrcTraceListener(this);
                Trace.Listeners.Add(_traceListener);
            }
            else if ((_traceListener != null) && !_config.EnableTrace && !_server.EnableTrace)
            {
                Trace.Listeners.Remove(_traceListener);
                _traceListener = null;
            }

        }
        
        /// <summary>
        /// 
        /// </summary>
        public void LoadFilters()
        {
            // filters 読み取り
            String path = Path.Combine(ConfigBasePath, Path.Combine(_username, "Filters.xml"));
            try
            {
                _filter = Filters.Load(path);
            }
            catch (IOException ie)
            {
                SendTwitterGatewayServerMessage("エラー: " + ie.Message);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        public void LoadGroups()
        {
            // group 読み取り
            lock (_groups)
            {
                String path = Path.Combine(ConfigBasePath, Path.Combine(_username, "Groups.xml"));
                try
                {
                    _groups = Groups.Load(path);

                    // 下位互換性FIX: グループに自分自身のNICKは存在しないようにします
                    foreach (Group g in _groups.Values)
                    {
                        g.Members.Remove(_nick);
                    }
                }
                catch (IOException ie)
                {
                    SendTwitterGatewayServerMessage("エラー: " + ie.Message);
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        public void SaveGroups()
        {
            // group 読み取り
            lock (_groups)
            {
                String path = Path.Combine(ConfigBasePath, Path.Combine(_username, "Groups.xml"));
                try
                {
                    _groups.Save(path);
                }
                catch (IOException ie)
                {
                    SendTwitterGatewayServerMessage("エラー: " + ie.Message);
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        public void LoadConfig()
        {
            lock (_config)
            {
                String path = Path.Combine(ConfigBasePath, Path.Combine(_username, "Config.xml"));
                try
                {
                    _config = Config.Load(path);
                }
                catch (IOException ie)
                {
                    SendTwitterGatewayServerMessage("エラー: " + ie.Message);
                }
            }
        }        
        /// <summary>
        /// 
        /// </summary>
        public void SaveConfig()
        {
            lock (_config)
            {
                String path = Path.Combine(ConfigBasePath, Path.Combine(_username, "Config.xml"));
                try
                {
                    _config.Save(path);
                    OnConfigChanged();
                }
                catch (IOException ie)
                {
                    SendTwitterGatewayServerMessage("エラー: " + ie.Message);
                }
            }
        }

        #endregion

        private Group GetGroupByChannelName(String channelName)
        {
            // グループを取得/作成
            Group group;
            if (!_groups.TryGetValue(channelName, out group))
            {
                group = new Group(channelName);
                _groups.Add(channelName, group);
            }
            return group;
        }

        #region メッセージ処理イベント
        private void MessageReceived_JOIN(object sender, MessageReceivedEventArgs e)
        {
            Trace.WriteLine(e.Message.ToString());
            if (!(e.Message is JoinMessage)) return;
            if (String.IsNullOrEmpty(e.Message.CommandParams[0]))
            {
                SendErrorReply(ErrorReply.ERR_NEEDMOREPARAMS, "Not enough parameters");
                return;
            }

            JoinMessage joinMsg = e.Message as JoinMessage;
            Trace.WriteLine(String.Format("Join: {0} -> {1}", joinMsg.Sender, joinMsg.Channel));
            String[] channelNames = joinMsg.Channel.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (String channelName in channelNames)
            {
                if (!channelName.StartsWith("#") || channelName.Length < 3 || String.Compare(channelName, _server.ChannelName, true) == 0)
                {
                    Trace.WriteLine(String.Format("No nick/such channel: {0}", channelName));
                    SendErrorReply(ErrorReply.ERR_NOSUCHCHANNEL, "No such nick/channel");
                    continue;
                }

                // グループを取得/作成
                Group group = GetGroupByChannelName(channelName);
                if (!group.IsJoined)
                {
                    joinMsg = new JoinMessage(channelName, "");
                    SendServer(joinMsg);

                    SendNumericReply(NumericReply.RPL_NAMREPLY, "=", channelName, String.Format("@{0} ", _nick) + String.Join(" ", group.Members.ToArray()));
                    SendNumericReply(NumericReply.RPL_ENDOFNAMES, channelName, "End of NAMES list");
                    group.IsJoined = true;

                    // mode
                    foreach (ChannelMode mode in group.ChannelModes)
                    {
                        Send(new ModeMessage(channelName, mode.ToString()));
                    }
                    
                    // Set topic of client, if topic was set
                    if (!String.IsNullOrEmpty(group.Topic))
                    {
                        Send(new TopicMessage(channelName, group.Topic));
                    }
                    else
                    {
                        SendNumericReply(NumericReply.RPL_NOTOPIC, channelName, "No topic is set");
                    }
                }
            }
       }

        private void MessageReceived_PART(object sender, MessageReceivedEventArgs e)
        {
            if (!(e.Message is PartMessage)) return;
            if (String.IsNullOrEmpty(e.Message.CommandParams[0]))
            {
                SendErrorReply(ErrorReply.ERR_NEEDMOREPARAMS, "Not enough parameters");
                return;
            }

            PartMessage partMsg = e.Message as PartMessage;
            Trace.WriteLine(String.Format("Part: {0} -> {1}", partMsg.Sender, partMsg.Channel));
            String[] channelNames = partMsg.Channel.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (String channelName in channelNames)
            {
                if (!channelName.StartsWith("#") || channelName.Length < 3 || String.Compare(channelName, _server.ChannelName, true) == 0)
                {
                    SendErrorReply(ErrorReply.ERR_NOSUCHCHANNEL, "No such nick/channel");
                    continue;
                }

                // グループを取得/作成
                Group group;
                if (_groups.TryGetValue(channelName, out group))
                {
                    group.IsJoined = false;
                }
                else
                {
                    SendErrorReply(ErrorReply.ERR_NOTONCHANNEL, "You're not on that channel");
                    continue;
                }
                partMsg = new PartMessage(channelName, "");
                SendServer(partMsg);

                // もう捨てていい?
                if (group.Members.Count == 0)
                {
                    _groups.Remove(group.Name);
                    SendTwitterGatewayServerMessage("グループ \""+group.Name+"\" を削除しました。");
                }
            }
        }
        private void MessageReceived_KICK(object sender, MessageReceivedEventArgs e)
        {
            if (String.Compare(e.Message.Command, "KICK", true) != 0) return;

            String[] channels = e.Message.CommandParams[0].Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            String[] kickTargets = e.Message.CommandParams[1].Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            if (channels.Length == 0 || (channels.Length != 1 && channels.Length != kickTargets.Length))
            {
                SendErrorReply(ErrorReply.ERR_NEEDMOREPARAMS, "Not enough parameters");
                return;
            }

            if (channels.Length == 1)
            {
                // 一チャンネルから複数けりだす
                Group group;
                if (!_groups.TryGetValue(channels[0], out group))
                {
                    SendErrorReply(ErrorReply.ERR_NOTONCHANNEL, "You're not on that channel");
                    return;
                }
                foreach (String kickTarget in kickTargets)
                {
                    if (group.Exists(kickTarget))
                    {
                        group.Remove(kickTarget);

                        OtherMessage kickMsg = new OtherMessage("KICK");
                        kickMsg.Sender = e.Message.Sender;
                        kickMsg.CommandParams[0] = channels[0];
                        kickMsg.CommandParams[1] = kickTarget;
                        kickMsg.CommandParams[2] = e.Message.CommandParams[2];
                        Send(kickMsg);
                    }
                    else
                    {
                        SendErrorReply(ErrorReply.ERR_NOSUCHNICK, "No such nick/channel");
                        return;
                    }
                }
            }
            else
            {
                // 複数チャンネルからそれぞれ
                for (Int32 i = 0; i < channels.Length; i++)
                {
                    String channelName = channels[i];
                    Group group;
                    if (!_groups.TryGetValue(channelName, out group))
                    {
                        SendErrorReply(ErrorReply.ERR_NOTONCHANNEL, "You're not on that channel");
                        return;
                    }
                    if (group.Exists(kickTargets[i]))
                    {
                        group.Remove(kickTargets[i]);
                        
                        OtherMessage kickMsg = new OtherMessage("KICK");
                        kickMsg.Sender = e.Message.Sender;
                        kickMsg.CommandParams[0] = group.Name;
                        kickMsg.CommandParams[1] = kickTargets[i];
                        kickMsg.CommandParams[2] = e.Message.CommandParams[2];
                        Send(kickMsg);
                    }
                    else
                    {
                        SendErrorReply(ErrorReply.ERR_NOSUCHNICK, "No such nick/channel");
                        return;
                    }
                }
            }

            SaveGroups();
        }
        private void MessageReceived_LIST(object sender, MessageReceivedEventArgs e)
        {
            if (String.Compare(e.Message.Command, "LIST", true) != 0) return;
            foreach (Group group in _groups.Values)
            {
                SendNumericReply(NumericReply.RPL_LIST, group.Name, group.Members.Count.ToString(), "");
            }
            SendNumericReply(NumericReply.RPL_LISTEND, "End of LIST");
        }
        private void MessageReceived_INVITE(object sender, MessageReceivedEventArgs e)
        {
            if (String.Compare(e.Message.Command, "INVITE", true) != 0) return;
            if (String.IsNullOrEmpty(e.Message.CommandParams[0]))
            {
                SendErrorReply(ErrorReply.ERR_NONICKNAMEGIVEN, "No nickname given");
                return;
            }

            String userName = e.Message.CommandParams[0];
            String channelName = e.Message.CommandParams[1];
            Trace.WriteLine(String.Format("Invite: {0} -> {1}", userName, channelName));
            if (!channelName.StartsWith("#") || channelName.Length < 3 || String.Compare(channelName, _server.ChannelName, true) == 0)
            {
                SendErrorReply(ErrorReply.ERR_NOSUCHCHANNEL, "No such nick/channel");
                return;
            }

            // グループを取得、ユーザ追加
            Group group = GetGroupByChannelName(channelName);
            if (!group.Exists(userName))
            {
                group.Add(userName);
            }
            if (group.IsJoined)
            {
                JoinMessage joinMsg = new JoinMessage(channelName, "");
                joinMsg.SenderHost = "twitter@" + Server.ServerName;
                joinMsg.SenderNick = userName;
                Send(joinMsg);
            }

            SaveGroups();
        }

        private void MessageReceived_USER(object sender, MessageReceivedEventArgs e)
        {
            if (!(e.Message is UserMessage)) return;

            if (String.IsNullOrEmpty(_nick))
            {
                SendErrorReply(ErrorReply.ERR_NONICKNAMEGIVEN, "No nickname given");
                return;
            }
            else if (String.IsNullOrEmpty(_password))
            {
                SendErrorReply(ErrorReply.ERR_PASSWDMISMATCH, "Password Incorrect");
                return;
            }

            //_username = e.Message.CommandParams[0]; // usernameがtwitterのIDとなる
            _username = e.Message.CommandParams[3];

            Type t = typeof(Server);
            _clientHost = String.Format("{0}!{1}@{2}", _nick, e.Message.CommandParams[0], ((IPEndPoint)(e.Client.Client.RemoteEndPoint)).Address);

            SendNumericReply(NumericReply.RPL_WELCOME
                , String.Format("Welcome to the Internet Relay Network {0}", _clientHost));
            SendNumericReply(NumericReply.RPL_YOURHOST
                , String.Format("Your host is {0}, running version {1}", t.FullName, t.Assembly.GetName().Version));
            SendNumericReply(NumericReply.RPL_CREATED
                , String.Format("This server was created {0}", DateTime.Now));
            SendNumericReply(NumericReply.RPL_MYINFO
                , String.Format("{0} {1}-{2} {3} {4}", Environment.MachineName, t.FullName, t.Assembly.GetName().Version, "", ""));

            JoinMessage joinMsg = new JoinMessage(_server.ChannelName, "");
            PrivMsgMessage autoMsg = new PrivMsgMessage();
            autoMsg.SenderNick = Server.ServerNick;
            autoMsg.SenderHost = "twitter@" + Server.ServerName;
            autoMsg.Receiver = _server.ChannelName;
            autoMsg.Content = "Twitter IRC Gateway Server Connected.";

            SendServer(joinMsg);
            Send(autoMsg);

            //
            // Twitte Service Setup
            //
            _twitter = new TwitterService(_username, _password);
            _twitter.CookieLoginMode = _server.CookieLoginMode;
            _twitter.Interval = _server.Interval;
            _twitter.IntervalDirectMessage = _server.IntervalDirectMessage;
            _twitter.IntervalReplies = _server.IntervalReplies;
            _twitter.EnableRepliesCheck = _server.EnableRepliesCheck;
            _twitter.POSTFetchMode = _server.POSTFetchMode;
            _twitter.RepliesReceived += new EventHandler<StatusesUpdatedEventArgs>(twitter_RepliesReceived);
            _twitter.TimelineStatusesReceived += new EventHandler<StatusesUpdatedEventArgs>(twitter_TimelineStatusesReceived);
            _twitter.CheckError += new EventHandler<ErrorEventArgs>(twitter_CheckError);
            _twitter.DirectMessageReceived += new EventHandler<DirectMessageEventArgs>(twitter_DirectMessageReceived);
            if (_server.Proxy != null)
                _twitter.Proxy = _server.Proxy;

            OnSessionStarted(_username);
            Trace.WriteLine(String.Format("SessionStarted: UserName={0}; Nickname={1}", _username, _nick));

            _twitter.Start();
        }

        void MessageReceived_NICK(object sender, MessageReceivedEventArgs e)
        {
            if (!(e.Message is NickMessage)) return;

            _nick = ((NickMessage)(e.Message)).NewNick;
        }

        void MessageReceived_PASS(object sender, MessageReceivedEventArgs e)
        {
            if (String.Compare(e.Message.Command, "PASS", true) != 0) return;

            if (e.Message.CommandParam.Length != 0)
            {
                _password = e.Message.CommandParam.Substring(1);
            }
        }

        void MessageReceived_QUIT(object sender, MessageReceivedEventArgs e)
        {
            if (!(e.Message is QuitMessage)) return;

            try
            {
                e.Client.Close();
            }
            catch { }
        }

        void MessageReceived_PRIVMSG(object sender, MessageReceivedEventArgs e)
        {
            PrivMsgMessage message = e.Message as PrivMsgMessage;
            if (message == null) return;

            StatusUpdateEventArgs eventArgs = new StatusUpdateEventArgs(message, message.Content);
            if (!FireEvent(PreSendUpdateStatus, eventArgs)) return;

            Boolean isRetry = false;
            Retry:
            try
            {
                // チャンネル宛は自分のメッセージを書き換え
                if ((String.Compare(message.Receiver, _server.ChannelName, true) == 0) || message.Receiver.StartsWith("#"))
                {
                    try
                    {
                        Status status = _twitter.UpdateStatus(message.Content);
                        if (status != null)
                        {
                            Trace.WriteLineIf(status != null, String.Format("Status Update: {0} (ID:{1}, CreatedAt:{2})", status.Text, status.Id.ToString(), status.CreatedAt.ToString()));

                            _lastStatusIdsFromGateway.AddLast(status.Id);
                            if (_lastStatusIdsFromGateway.Count > 100)
                            {
                                _lastStatusIdsFromGateway.RemoveFirst();
                            }
                        }
                    }
                    catch (TwitterServiceException tse)
                    {
                        SendTwitterGatewayServerMessage("エラー: メッセージは完了しましたが、レスポンスを正しく受信できませんでした。(" + tse.Message + ")");
                    }

                    // topic にする
                    if (_server.SetTopicOnStatusChanged)
                    {
                        TopicMessage topicMsg = new TopicMessage(_server.ChannelName, message.Content);
                        topicMsg.Sender = _clientHost;
                        Send(topicMsg);
                    }

                    // 他のチャンネルにも投げる
                    if (_server.BroadcastUpdate)
                    {
                        // #Twitter
                        if (String.Compare(message.Receiver, _server.ChannelName, true) != 0)
                        {
                            // XXX: 例によってIRCライブラリのバージョンアップでどうにかしたい
                            if (_server.BroadcastUpdateMessageIsNotice)
                            {
                                Send(new NoticeMessage()
                                {
                                    Sender = _clientHost,
                                    Receiver = _server.ChannelName,
                                    Content = message