source: trunk/CrypPlugins/KeySearcher/P2P/Storage/StorageHelper.cs @ 1703

Last change on this file since 1703 was 1703, checked in by Paul Lelgemann, 12 years ago

o P2PEditor: fix for local filename problem
+ KeySearcher: debug log entry for sent/received bytes

File size: 5.8 KB
Line 
1using System;
2using System.IO;
3using Cryptool.P2P;
4using Cryptool.P2P.Internal;
5using KeySearcher.P2P.Presentation;
6using KeySearcher.P2P.Tree;
7
8namespace KeySearcher.P2P.Storage
9{
10    class StorageHelper
11    {
12        private readonly KeySearcher keySearcher;
13        private readonly StatisticsGenerator statisticsGenerator;
14        private readonly StatusContainer statusContainer;
15
16        public StorageHelper(KeySearcher keySearcher, StatisticsGenerator statisticsGenerator, StatusContainer statusContainer)
17        {
18            this.keySearcher = keySearcher;
19            this.statisticsGenerator = statisticsGenerator;
20            this.statusContainer = statusContainer;
21        }
22
23        internal RequestResult UpdateInDht(NodeBase nodeToUpdate)
24        {
25            var memoryStream = new MemoryStream();
26            var binaryWriter = new BinaryWriter(memoryStream);
27
28            if (nodeToUpdate is Node)
29            {
30                UpdateNodeInDht((Node) nodeToUpdate, binaryWriter);
31            } else
32            {
33                UpdateLeafInDht((Leaf) nodeToUpdate, binaryWriter);
34            }
35
36            // Append results
37            binaryWriter.Write(nodeToUpdate.Result.Count);
38            foreach (var valueKey in nodeToUpdate.Result)
39            {
40                binaryWriter.Write(valueKey.key);
41                binaryWriter.Write(valueKey.value);
42                binaryWriter.Write(valueKey.decryption.Length);
43                binaryWriter.Write(valueKey.decryption);
44            }
45
46            return StoreWithStatistic(KeyInDht(nodeToUpdate), memoryStream.ToArray());
47        }
48
49        private static void UpdateNodeInDht(Node nodeToUpdate, BinaryWriter binaryWriter)
50        {
51            binaryWriter.Write(nodeToUpdate.LeftChildFinished);
52            binaryWriter.Write(nodeToUpdate.RightChildFinished);
53        }
54
55        private static void UpdateLeafInDht(Leaf nodeToUpdate, BinaryWriter binaryWriter)
56        {
57            var buffer = nodeToUpdate.LastReservationDate.ToBinary();
58            binaryWriter.Write(buffer);
59        }
60
61        internal RequestResult UpdateFromDht(NodeBase nodeToUpdate, bool forceUpdate = false)
62        {
63            if (!forceUpdate && nodeToUpdate.LastUpdate > DateTime.Now.Subtract(new TimeSpan(0, 0, 5)))
64            {
65                return new RequestResult { Status = RequestResultType.Success };
66            }
67
68            nodeToUpdate.LastUpdate = DateTime.Now;
69
70            var requestResult = RetrieveWithStatistic(KeyInDht(nodeToUpdate));
71            var nodeBytes = requestResult.Data;
72
73            if (nodeBytes == null)
74            {
75                return requestResult;
76            }
77
78            var binaryReader = new BinaryReader(new MemoryStream(nodeBytes));
79
80            if (nodeToUpdate is Node)
81            {
82                UpdateNodeFromDht((Node) nodeToUpdate, binaryReader);
83            } else
84            {
85                UpdateLeafFromDht((Leaf) nodeToUpdate, binaryReader);
86            }
87
88            // Load results
89            var resultCount = binaryReader.ReadInt32();
90            for (var i = 0; i < resultCount; i++)
91            {
92                var newResult = new KeySearcher.ValueKey
93                                    {
94                                        key = binaryReader.ReadString(),
95                                        value = binaryReader.ReadDouble(),
96                                        decryption = binaryReader.ReadBytes(binaryReader.ReadInt32())
97                                    };
98                nodeToUpdate.Result.AddLast(newResult);
99            }
100
101            if (resultCount > 0)
102            {
103                keySearcher.IntegrateNewResults(nodeToUpdate.Result);
104                statisticsGenerator.ProcessPatternResults(nodeToUpdate.Result);
105            }
106
107            nodeToUpdate.UpdateCache();
108            return requestResult;
109        }
110
111        private static void UpdateNodeFromDht(Node nodeToUpdate, BinaryReader binaryReader)
112        {
113            nodeToUpdate.LeftChildFinished = binaryReader.ReadBoolean() || nodeToUpdate.LeftChildFinished;
114            nodeToUpdate.RightChildFinished = binaryReader.ReadBoolean() || nodeToUpdate.RightChildFinished;
115        }
116
117        private static void UpdateLeafFromDht(Leaf nodeToUpdate, BinaryReader binaryReader)
118        {
119            var date = DateTime.FromBinary(binaryReader.ReadInt64());
120            if (date > nodeToUpdate.LastReservationDate)
121            {
122                nodeToUpdate.LastReservationDate = date;
123            }
124        }
125
126        internal static string KeyInDht(NodeBase node)
127        {
128            return string.Format("{0}_node_{1}_{2}", node.DistributedJobIdentifier, node.From, node.To);
129        }
130
131        public RequestResult RetrieveWithStatistic(string key)
132        {
133            statusContainer.RetrieveRequests++;
134            statusContainer.TotalDhtRequests++;
135            var requestResult = P2PManager.Retrieve(key);
136
137            if (requestResult.Data != null)
138            {
139                statusContainer.RetrievedBytes += requestResult.Data.Length;
140            }
141
142            return requestResult;
143        }
144
145        public RequestResult RemoveWithStatistic(string key)
146        {
147            statusContainer.RemoveRequests++;
148            statusContainer.TotalDhtRequests++;
149            return P2PManager.Remove(key);
150        }
151
152        public RequestResult StoreWithStatistic(string key, byte[] data)
153        {
154            statusContainer.StoreRequests++;
155            statusContainer.TotalDhtRequests++;
156            var requestResult = P2PManager.Store(key, data);
157
158            if (requestResult.Data != null)
159            {
160                statusContainer.StoredBytes += requestResult.Data.Length;
161            }
162
163            return requestResult;
164        }
165    }
166}
Note: See TracBrowser for help on using the repository browser.