예제 #1
0
파일: RouteTable.cs 프로젝트: asapo/Profes
        protected RouteTable(SerializationInfo info, StreamingContext context)
        {
            _nodeList = (Node[][])info.GetValue("_nodeList", typeof(Node[][]));
            _myNode = (Node)info.GetValue("MyNode", typeof(Node));

            TimerEvent();
        }
예제 #2
0
파일: Key.cs 프로젝트: asapo/Profes
 /// <summary>
 /// Cacheリストを追加します
 /// </summary>
 public void AddRange(IEnumerable<Cache> collection, Node node)
 {
     foreach (Cache item in collection)
     {
         this.Add(item, node);
     }
 }
예제 #3
0
파일: Key.cs 프로젝트: asapo/Profes
        /// <summary>
        /// Cacheを追加します
        /// </summary>
        public void Add(Cache item, Node node)
        {
            if (item == null) return;
            if (item.Key == null) return;

            Key key = item.Key;
            key.FileLocation = node;
            key.KeyCreateTime = DateTime.Now;

            key.CacheBlockBitmap = new bool[item.CacheBlockHash.Length];

            string stringHash = BinaryEditor.BytesToHexString(item.Hash);
            for (int i = 0; i < item.CacheBlockHash.Length; i++)
            {
                if (Settings.Default._cacheController.ContainsKey(stringHash) && Settings.Default._cacheController[stringHash][i] != null)
                {
                    key.CacheBlockBitmap[i] = true;
                }
            }

            lock (_myReviewDic)
            {
                string stringSignatureHash = BinaryEditor.BytesToHexString(item.SignatureHash);
                if (_myReviewDic.ContainsKey(stringSignatureHash))
                    key.Review = _myReviewDic[stringSignatureHash];
            }

            this.Add(key);
        }
예제 #4
0
파일: RouteTable.cs 프로젝트: asapo/Profes
        private bool DeadNodeCheck(Node node)
        {
            string nodeIdString = BinaryEditor.BytesToHexString(node.NodeID);

            if (_deadNodeDic.ContainsKey(nodeIdString))
            {
                var t = DateTime.Now - _deadNodeDic[nodeIdString];

                if (t.Hours < 1)
                {
                    return true;
                }
            }

            return false;
        }
예제 #5
0
파일: RouteTable.cs 프로젝트: asapo/Profes
        /// <summary>
        /// RouteTableクラスの新しいインスタンスを初期化します
        /// </summary>
        /// <param name="myNode">自分自身のノード情報を指定する</param>
        public RouteTable(Node myNode)
        {
            this.MyNode = myNode;

            TimerEvent();
        }
예제 #6
0
파일: RouteTable.cs 프로젝트: asapo/Profes
        /// <summary>
        /// ノードを削除する
        /// </summary>
        /// <param name="node"></param>
        public void Remove(Node node)
        {
            lock (this)
            {
                int i = Xor(this.MyNode.NodeID, node.NodeID);

                if (_nodeList[i] != null)
                {
                    int index = 0;
                    while (_nodeList[i].Count(n => n != null) > index &&
                        BinaryEditor.ArrayEquals(_nodeList[i][index].NodeID, node.NodeID)) index++;

                    if (_nodeList[i].Count(n => n != null) > index)
                    {
                        _nodeList[i][index] = null;
                        _nodeList[i] = _nodeList[i].OrderBy(n => n == null).ToArray();
                    }
                }
            }
        }
예제 #7
0
파일: RouteTable.cs 프로젝트: asapo/Profes
        /// <summary>
        /// ノードを検索する
        /// </summary>
        /// <param name="key">検索するノードID</param>
        /// <returns>距離の近いノードを返す</returns>
        public Node[] Search(byte[] key)
        {
            Node[][] tempNodeList = new Node[256 + 1][];
            List<Node> tempOneList = new List<Node>();

            lock (this)
            {
                for (int i = 0; i < _nodeList.Length; i++)
                {
                    for (int j = 0; _nodeList[i] != null && j < _nodeList[i].Length && _nodeList[i][j] != null; j++)
                    {
                        int index = Xor(key, _nodeList[i][j].NodeID);

                        if (tempNodeList[index] == null)
                        {
                            tempNodeList[index] = new Node[MAX_NODELIST_LENGTH];
                        }
                        if (tempNodeList[index].Count(n => n != null) < MAX_NODELIST_LENGTH)
                        {
                            tempNodeList[index][tempNodeList[index].Count(n => n != null)] = _nodeList[i][j];
                        }
                    }
                }
            }

            for (int i = 0; i < tempNodeList.Length; i++)
            {
                for (int j = 0; tempNodeList[i] != null && j < tempNodeList[i].Length && tempNodeList[i][j] != null; j++)
                {
                    if (tempOneList.Count <= 100) tempOneList.Add(tempNodeList[i][j]);
                }
            }

            return tempOneList.ToArray();
        }
예제 #8
0
파일: RouteTable.cs 프로젝트: asapo/Profes
 /// <summary>
 /// ノードリストを追加する
 /// </summary>
 /// <param name="Nodes">追加するノードリスト</param>
 public void AddRange(Node[] Nodes)
 {
     foreach (Node node in Nodes)
     {
         this.Add(node);
     }
 }
예제 #9
0
파일: RouteTable.cs 프로젝트: asapo/Profes
 /// <summary>
 /// 死亡ノードを追加する
 /// </summary>
 /// <param name="node"></param>
 public void AddDeadNode(Node node)
 {
     _deadNodeDic[BinaryEditor.BytesToHexString(node.NodeID)] = DateTime.Now;
 }
예제 #10
0
파일: RouteTable.cs 프로젝트: asapo/Profes
        /// <summary>
        /// ノードを追加する
        /// </summary>
        /// <param name="node">追加するノード</param>
        public void Add(Node node)
        {
            if (node == null) return;
            if (!Verification.VerificationIPAddress(node.Endpoint)) return;
            if (DeadNodeCheck(node)) return;
            if (_pingNodeList.Any(n => BinaryEditor.ArrayEquals(n.NodeID, node.NodeID))) return;

            int i = Xor(MyNode.NodeID, node.NodeID);

            if (i == 0) return;

            lock (this)
            {
                // 追加するnodeがNodeListに入っている場合、そのノードをNodeListの末尾に移す
                if (_nodeList[i] != null && true == _nodeList[i].Any(n => n != null && BinaryEditor.ArrayEquals(n.NodeID, node.NodeID)))
                {
                    _nodeList[i] = _nodeList[i].OrderBy(n => n == null || BinaryEditor.ArrayEquals(n.NodeID, node.NodeID)).ToArray();
                }
                // 追加するnodeがNodeListの中に存在しない場合
                else if (_nodeList[i] != null)
                {
                    if (_nodeList[i].Count(n => n == null) == 0)
                    {
                        Node checkNode = _nodeList[i].FirstOrDefault(n => n != null && !_pingNodeList.Any(m => BinaryEditor.ArrayEquals(n.NodeID, m.NodeID)));
                        if (checkNode != null) _pingNodeList.Add(checkNode);
                    }

                    if (_nodeList[i].Count(n => n != null) < MAX_NODELIST_LENGTH)
                    {
                        _nodeList[i][_nodeList[i].Count(n => n != null)] = node;
                        _nodeList[i] = _nodeList[i].OrderBy(n => n == null || BinaryEditor.ArrayEquals(n.NodeID, node.NodeID)).ToArray();
                    }
                }
                else
                {
                    _nodeList[i] = new Node[MAX_NODELIST_LENGTH];
                    _nodeList[i][0] = node;
                }
            }
        }
예제 #11
0
        bool _routeTable_Ping(object sender, Node e)
        {
            try
            {
                using (ChannelFactory<IFileShareService> channel = new ChannelFactory<IFileShareService>("Tcp_Client", e.Endpoint))
                {
                    IFileShareService proxy = channel.CreateChannel();
                    Settings.Default._routeTable.AddRange(proxy.GetRouteTable(new byte[] { 0 }));

                    LogWrite("_routeTable_Ping成功:ノードの生存を確認しました");

                    return true;
                }
            }
            catch (EndpointNotFoundException ex)
            {
                LogWrite("_routeTable_Ping成功:ノードの死亡を確認しました");

                Debug.WriteLine("_routeTable_Ping" + ex.Message);
                return false;
            }
            catch (TimeoutException ex)
            {
                LogWrite("_routeTable_Ping成功:ノードの死亡を確認しました");

                Debug.WriteLine("_routeTable_Ping" + ex.Message);
                return false;
            }
            catch (FaultException ex)
            {
                LogWrite("_routeTable_Ping成功:ノードの死亡を確認しました");

                Debug.WriteLine("_routeTable_Ping" + ex.Message);
                return false;
            }
            catch (CommunicationException ex)
            {
                LogWrite("_routeTable_Ping成功:ノードの死亡を確認しました");

                Debug.WriteLine("_routeTable_Ping" + ex.Message);
                return false;
            }
            catch (NullReferenceException ex)
            {
                LogWrite("_routeTable_Ping成功:ノードの死亡を確認しました");

                Debug.WriteLine("_routeTable_Ping" + ex.Message);
                return false;
            }
        }
예제 #12
0
        /// <summary>
        /// �T�[�r�X��J�n����
        /// </summary>
        private void StartService()
        {
            LogWrite("�T�[�r�X�J�n");

            Node node = new Node();
            switch (Settings.Default.ConnectionType)
            {
                case ConnectionType.Direct:
                    if (Settings.Default.DirectConnectionInformation.IPAddress.Contains(":"))
                    {
                        node.Endpoint = new EndpointAddress(string.Format("net.tcp://[{0}]:{1}/FileShareService",
                            Settings.Default.DirectConnectionInformation.IPAddress, Settings.Default.DirectConnectionInformation.Port));
                    }
                    else
                    {
                        node.Endpoint = new EndpointAddress(string.Format("net.tcp://{0}:{1}/FileShareService",
                            Settings.Default.DirectConnectionInformation.IPAddress, Settings.Default.DirectConnectionInformation.Port));
                    }

                    Settings.Default._routeTable.MyNode = node;

                    break;

                case ConnectionType.UPnP:
                    node.Endpoint = new EndpointAddress(string.Format("net.tcp://{0}:{1}/FileShareService",
                        Settings.Default.UpnpConnectionInformation.GlobalIPAddress, Settings.Default.UpnpConnectionInformation.ExternalPort));

                    if (!UPnPClient.OpenFirewallPort(Settings.Default.UpnpConnectionInformation.MachineIPAddress,
                        Settings.Default.UpnpConnectionInformation.GatewayIPAddress,
                        Settings.Default.UpnpConnectionInformation.ExternalPort,
                        Settings.Default.UpnpConnectionInformation.InternalPort))
                    {
                        MessageBox.Show("�|�[�g���J���ł��܂���ł����B");

                        this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
                        {
                            MessageBoxStatusBarItem.Content = "UPnP�ɂ��|�[�g�J�����s";
                        }));

                        return;
                    }

                    Settings.Default._routeTable.MyNode = node;

                    break;

                case ConnectionType.Other:
                    node.Endpoint = new EndpointAddress(string.Format("net.tcp://{0}:{1}/FileShareService",
                        Settings.Default.OtherConnectionInformation.IPAddress, Settings.Default.OtherConnectionInformation.Port));

                    Settings.Default._routeTable.MyNode = node;

                    break;
            }

            LogWrite(string.Format("MyNode Uri: \"{0}\" ID: \"{1}\"", node.Endpoint.ToString(),
                BinaryEditor.BytesToHexString(node.NodeID)));

            _serviceHostThread = new Thread(new ThreadStart(delegate()
            {
                try
                {
                    Node serviceNode = new Node();

                    switch (Settings.Default.ConnectionType)
                    {
                        case ConnectionType.Direct:
                            serviceNode = Settings.Default._routeTable.MyNode;

                            break;

                        case ConnectionType.UPnP:
                            serviceNode.Endpoint = new EndpointAddress(string.Format("net.tcp://{0}:{1}/FileShareService",
                                Settings.Default.UpnpConnectionInformation.MachineIPAddress, Settings.Default.UpnpConnectionInformation.InternalPort));

                            break;

                        case ConnectionType.Other:
                            serviceNode.Endpoint = new EndpointAddress(string.Format("net.tcp://0.0.0.0:{0}/FileShareService",
                                Settings.Default.OtherConnectionInformation.Port));

                            break;
                    }

                    Settings.Default._serviceHost = new ServiceHost(typeof(FileShareService), serviceNode.Endpoint.Uri);
                    Settings.Default._serviceHost.Open();

                    LogWrite(string.Format("ServiceHost Uri: \"{0}\" ID: \"{1}\"", serviceNode.Endpoint.ToString(),
                        BinaryEditor.BytesToHexString(serviceNode.NodeID)));

                    StartEvent();
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message,
                        "Profes, Profes.P2P.FileShare.dll",
                        MessageBoxButton.OK,
                        MessageBoxImage.Error);

                    try
                    {
                        Settings.Default._serviceHost.Abort();
                    }
                    catch{ }

                    this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
                    {
                        MessageBoxStatusBarItem.Content = "�g�p�ł��Ȃ�IP�A�h���X";
                    }));
                }
            }));

            _serviceHostThread.Start();

            Settings.Default.IsServiceStarted = true;

            this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
            {
                MessageBoxStatusBarItem.Content = "�T�[�r�X�J�n";
            }));
        }