beagled/QueryResult.cs

   1 //
   2 // QueryResult.cs
   3 //
   4 // Copyright (C) 2004 Novell, Inc.
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a
   9 // copy of this software and associated documentation files (the "Software"),
  10 // to deal in the Software without restriction, including without limitation
  11 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12 // and/or sell copies of the Software, and to permit persons to whom the
  13 // Software is furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24 // DEALINGS IN THE SOFTWARE.
  25 //
  26
  27
  28 using System;
  29 using System.Collections;
  30 using System.Diagnostics;
  31 using System.Threading;
  32 using Beagle.Util;
  33
  34 namespace Beagle.Daemon {
  35
  36         public class QueryResult : IQueryResult, IDisposable {
  37
  38                 public delegate void StartedHandler (QueryResult source);
  39                 public event StartedHandler StartedEvent;
  40
  41                 public delegate void HitsAddedHandler (QueryResult source, ICollection someHits, int total_results);
  42                 public event HitsAddedHandler HitsAddedEvent;
  43
  44                 public delegate void HitsSubtractedHandler (QueryResult source, ICollection someUris);
  45                 public event HitsSubtractedHandler HitsSubtractedEvent;
  46
  47                 public delegate void FinishedHandler (QueryResult source);
  48                 public event FinishedHandler FinishedEvent;
  49
  50                 //////////////////////////////////
  51
  52                 int workers = 0;
  53                 bool cancelled = false;
  54                 Hashtable uri_hash = UriFu.NewHashtable ();
  55                 DateTime started_time;
  56                 DateTime finished_time;
  57                 Hashtable per_worker_started_time = new Hashtable ();
  58                 bool is_index_listener = false;
  59
  60
  61                 public QueryResult ()
  62                 {
  63
  64                 }
  65
  66                 //////////////////////////////////
  67
  68                 public void Dispose ()
  69                 {
  70                         lock (this) {
  71                                 if (cancelled)
  72                                         return;
  73                                 cancelled = true;
  74                         }
  75                 }
  76
  77                 //////////////////////////////////
  78
  79                 public bool Active {
  80                         get { return workers > 0 && ! cancelled; }
  81                 }
  82
  83                 public bool Cancelled {
  84                         get { return cancelled; }
  85                 }
  86
  87                 public bool IsIndexListener {
  88                         get { return is_index_listener; }
  89                         set { is_index_listener = value; }
  90                 }
  91
  92                 public void Cancel ()
  93                 {
  94                         lock (this) {
  95                                 if (cancelled)
  96                                         return;
  97                                 cancelled = true;
  98                         }
  99                 }
 100
 101                 public void Add (ICollection some_hits)
 102                 {
 103                         Add (some_hits, -1);
 104                 }
 105
 106                 // Note: some_hits is allowed to contain null.
 107                 // They are silently ignored.
 108                 public void Add (ICollection some_hits, int total_results)
 109                 {
 110                         lock (this) {
 111                                 if (cancelled)
 112                                         return;
 113
 114                                 Debug.Assert (workers > 0, "Adding Hits to idle QueryResult");
 115
 116                                 if (some_hits.Count == 0)
 117                                         return;
 118
 119                                 if (IsIndexListener) {
 120                                         if (HitsAddedEvent != null)
 121                                                 HitsAddedEvent (this, some_hits, total_results);
 122                                         return;
 123                                 }
 124
 125                                 // Be careful not to report the same hit twice.
 126                                 ArrayList hits_to_report;
 127                                 hits_to_report = new ArrayList ();
 128                                 foreach (Hit hit in some_hits) {
 129                                         if (hit != null && ! uri_hash.Contains (hit.Uri)) {
 130                                                 uri_hash [hit.Uri] = hit;
 131                                                 hits_to_report.Add (hit);
 132                                         }
 133                                 }
 134
 135                                 if (HitsAddedEvent != null && hits_to_report.Count > 0)
 136                                         HitsAddedEvent (this, hits_to_report, total_results);
 137                         }
 138                 }
 139
 140                 // Note: some_uris is allowed to contain null.
 141                 // They are silently ignored.
 142                 public void Subtract (ICollection some_uris)
 143                 {
 144                         lock (this) {
 145                                 if (cancelled)
 146                                         return;
 147
 148                                 Debug.Assert (workers > 0, "Subtracting Hits from idle QueryResult");
 149
 150                                 if (some_uris.Count == 0)
 151                                         return;
 152
 153                                 if (IsIndexListener) {
 154                                         if (HitsSubtractedEvent != null)
 155                                                 HitsSubtractedEvent (this, some_uris);
 156                                         return;
 157                                 }
 158
 159                                 ArrayList filtered_uris = new ArrayList ();
 160
 161                                 // We only get to subtract a URI if it was previously added.
 162                                 foreach (Uri uri in some_uris) {
 163                                         if (uri != null && uri_hash.Contains (uri)) {
 164                                                 filtered_uris.Add (uri);
 165                                                 uri_hash.Remove (uri);
 166                                         }
 167                                 }
 168
 169                                 if (HitsSubtractedEvent != null && filtered_uris.Count > 0)
 170                                         HitsSubtractedEvent (this, filtered_uris);
 171                         }
 172                 }
 173
 174                 //////////////////////////////////
 175
 176                 // Given the Uri of a Hit contained in the QueryResult, return that Hit.
 177                 public Hit GetHitFromUri (Uri uri)
 178                 {
 179                         return uri_hash [uri] as Hit;
 180                 }
 181
 182                 public ICollection HitUris {
 183                         get { return uri_hash.Keys; }
 184                 }
 185
 186                 //////////////////////////////////////////////////////////////////////////////////////
 187
 188                 class QueryWorkerClosure {
 189                         IQueryWorker worker;
 190                         QueryResult result;
 191
 192                         public QueryWorkerClosure (IQueryWorker _worker, QueryResult _result)
 193                         {
 194                                 worker = _worker;
 195                                 result = _result;
 196                         }
 197
 198                         public void Start ()
 199                         {
 200                                 try {
 201                                         worker.DoWork ();
 202                                 } catch (Exception e) {
 203                                         Logger.Log.Error (e, "QueryWorker '{0}' threw an exception", worker);
 204                                 }
 205                                 try {
 206                                         result.WorkerFinished (worker);
 207                                 } catch (Exception e) {
 208                                         Logger.Log.Error ("QueryResult threw an exception while calling WorkerFinished for '{0}'",
 209                                                           worker);
 210                                 }
 211                         }
 212                 }
 213
 214                 public void AttachWorker (IQueryWorker worker)
 215                 {
 216                         lock (this) {
 217                                 if (cancelled)
 218                                         return;
 219
 220                                 QueryWorkerClosure qwc;
 221                                 qwc = new QueryWorkerClosure (worker, this);
 222
 223                                 // QueryDriver has an enclosing WorkerStart,
 224                                 // so if we call WorkerStart in this thread,
 225                                 // all the workers will have a chance
 226                                 // to start before Finished is called
 227
 228                                 if (!WorkerStartNoLock (worker))
 229                                         return;
 230
 231                                 ExceptionHandlingThread.Start (new ThreadStart (qwc.Start));
 232                         }
 233                 }
 234
 235                 private bool WorkerStartNoLock (object o)
 236                 {
 237                         if (!Shutdown.WorkerStart (o))
 238                                 return false;
 239
 240                         DateTime now = DateTime.Now;
 241                         per_worker_started_time [o] = now;
 242                         ++workers;
 243                         if (workers == 1) {
 244                                 started_time = now;
 245                                 if (StartedEvent != null)
 246                                         StartedEvent (this);
 247                         }
 248
 249
 250                         return true;
 251
 252                 }
 253
 254                 internal bool WorkerStart (object o)
 255                 {
 256                         lock (this) {
 257                                 return WorkerStartNoLock (o);
 258                         }
 259                 }
 260
 261                 internal void WorkerFinished (object o)
 262                 {
 263                         lock (this) {
 264                                 Debug.Assert (workers > 0, "Too many calls to WorkerFinished");
 265                                 --workers;
 266
 267
 268                                 DateTime now = DateTime.Now;
 269
 270                                 //DateTime then = (DateTime) per_worker_started_time [o];
 271                                 //Logger.Log.Debug ("{0} finished in {1:0.00}s", o, (now - then).TotalSeconds);
 272
 273                                 if (workers == 0) {
 274                                         finished_time = now;
 275                                         //Logger.Log.Debug ("Last worker finished {0:0.00}s after start",
 276                                         //(finished_time - started_time).TotalSeconds);
 277                                         if (FinishedEvent != null)
 278                                                 FinishedEvent (this);
 279                                         Monitor.Pulse (this);
 280                                 }
 281                         }
 282                         Shutdown.WorkerFinished (o);
 283                 }
 284
 285                 public void Wait ()
 286                 {
 287                         lock (this) {
 288                                 while (true) {
 289                                         if (cancelled || workers == 0)
 290                                                 return;
 291                                         Monitor.Wait (this);
 292                                 }
 293                         }
 294                 }
 295         }
 296 }