source/ch/cyberduck/ui/controller/TransferController.cs

   1 //
   2 // Copyright (c) 2010-2014 Yves Langisch. All rights reserved.
   3 // http://cyberduck.ch/
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14 //
  15 // Bug fixes, suggestions and comments should be sent to:
  16 // yves@cyberduck.ch
  17 //
  18
  19 using System;
  20 using System.Collections.Generic;
  21 using System.Drawing;
  22 using System.Windows.Forms;
  23 using ch.cyberduck.core;
  24 using ch.cyberduck.core.formatter;
  25 using ch.cyberduck.core.io;
  26 using ch.cyberduck.core.local;
  27 using ch.cyberduck.core.preferences;
  28 using ch.cyberduck.core.ssl;
  29 using ch.cyberduck.core.threading;
  30 using ch.cyberduck.core.transfer;
  31 using Ch.Cyberduck.Ui.Controller.Threading;
  32 using org.apache.log4j;
  33 using StructureMap;
  34
  35 namespace Ch.Cyberduck.Ui.Controller
  36 {
  37     public class TransferController : WindowController<ITransferView>, TranscriptListener, CollectionListener
  38     {
  39         private static readonly Logger Log = Logger.getLogger(typeof (TransferController).FullName);
  40         private static readonly object SyncRoot = new Object();
  41         private static volatile TransferController _instance;
  42
  43         private readonly IDictionary<Transfer, ProgressController> _transferMap =
  44             new Dictionary<Transfer, ProgressController>();
  45
  46         private TransferController()
  47         {
  48             View = ObjectFactory.GetInstance<ITransferView>();
  49             lock (TransferCollection.defaultCollection())
  50             {
  51                 foreach (Transfer transfer in TransferCollection.defaultCollection())
  52                 {
  53                     collectionItemAdded(transfer);
  54                 }
  55             }
  56             Init();
  57         }
  58
  59         public override bool Singleton
  60         {
  61             get { return true; }
  62         }
  63
  64         public static TransferController Instance
  65         {
  66             get
  67             {
  68                 if (_instance == null)
  69                 {
  70                     lock (SyncRoot)
  71                     {
  72                         if (_instance == null)
  73                             _instance = new TransferController();
  74                     }
  75                 }
  76                 return _instance;
  77             }
  78         }
  79
  80         public void collectionLoaded()
  81         {
  82         }
  83
  84         public void collectionItemAdded(object obj)
  85         {
  86             Invoke(delegate
  87             {
  88                 Transfer transfer = obj as Transfer;
  89                 ProgressController progressController = new ProgressController(transfer);
  90                 _transferMap.Add(new KeyValuePair<Transfer, ProgressController>(transfer, progressController));
  91                 IProgressView progressView = progressController.View;
  92                 View.AddTransfer(progressView);
  93                 View.SelectTransfer(progressView);
  94             });
  95         }
  96
  97         public void collectionItemRemoved(object obj)
  98         {
  99             Invoke(delegate
 100             {
 101                 Transfer transfer = obj as Transfer;
 102                 if (null != transfer)
 103                 {
 104                     ProgressController progressController;
 105                     if (_transferMap.TryGetValue(transfer, out progressController))
 106                     {
 107                         View.RemoveTransfer(progressController.View);
 108                     }
 109                 }
 110             });
 111         }
 112
 113         public void collectionItemChanged(object obj)
 114         {
 115         }
 116
 117         public override void log(bool request, string transcript)
 118         {
 119             if (View.TranscriptVisible)
 120             {
 121                 invoke(new LogAction(this, request, transcript));
 122             }
 123         }
 124
 125         public ProgressController GetController(Transfer transfer)
 126         {
 127             ProgressController progressController;
 128             if (!_transferMap.TryGetValue(transfer, out progressController))
 129             {
 130                 progressController = new ProgressController(transfer);
 131                 _transferMap.Add(transfer, new ProgressController(transfer));
 132             }
 133             return progressController;
 134         }
 135
 136         public static bool ApplicationShouldTerminate()
 137         {
 138             if (null != _instance)
 139             {
 140                 //Saving state of transfer window
 141                 PreferencesFactory.get().setProperty("queue.window.open.default", _instance.Visible);
 142                 if (TransferCollection.defaultCollection().numberOfRunningTransfers() > 0)
 143                 {
 144                     DialogResult result = _instance.QuestionBox(LocaleFactory.localizedString("Transfer in progress"),
 145                         LocaleFactory.localizedString("There are files currently being transferred. Quit anyway?"), null,
 146                         String.Format("{0}", LocaleFactory.localizedString("Exit")), true //Cancel
 147                         );
 148                     if (DialogResult.OK == result)
 149                     {
 150                         // Quit
 151                         for (int i = 0; i < _instance.getActions().size(); i++)
 152                         {
 153                             ((BackgroundAction) _instance.getActions().get(i)).cancel();
 154                         }
 155                         return true;
 156                     }
 157                     // Cancel
 158                     return false;
 159                 }
 160             }
 161             return true;
 162         }
 163
 164         private void Init()
 165         {
 166             TransferCollection.defaultCollection().addListener(this);
 167
 168             PopulateBandwithList();
 169
 170             View.PositionSizeRestoredEvent += delegate
 171             {
 172                 View.TranscriptVisible = PreferencesFactory.get().getBoolean("queue.transcript.open");
 173                 View.TranscriptHeight = PreferencesFactory.get().getInteger("queue.transcript.size.height");
 174
 175                 View.ToggleTranscriptEvent += View_ToggleTranscriptEvent;
 176                 View.TranscriptHeightChangedEvent += View_TranscriptHeightChangedEvent;
 177             };
 178             View.QueueSize = PreferencesFactory.get().getInteger("queue.maxtransfers");
 179             View.BandwidthEnabled = false;
 180
 181             View.ResumeEvent += View_ResumeEvent;
 182             View.ReloadEvent += View_ReloadEvent;
 183             View.StopEvent += View_StopEvent;
 184             View.RemoveEvent += View_RemoveEvent;
 185             View.CleanEvent += View_CleanEvent;
 186             View.OpenEvent += View_OpenEvent;
 187             View.ShowEvent += View_ShowEvent;
 188             View.TrashEvent += View_TrashEvent;
 189             View.SelectionChangedEvent += View_SelectionChangedEvent;
 190             View.BandwidthChangedEvent += View_BandwidthChangedEvent;
 191             View.QueueSizeChangedEvent += View_QueueSizeChangedEvent;
 192
 193             View.ValidateResumeEvent += View_ValidateResumeEvent;
 194             View.ValidateReloadEvent += View_ValidateReloadEvent;
 195             View.ValidateStopEvent += View_ValidateStopEvent;
 196             View.ValidateRemoveEvent += View_ValidateRemoveEvent;
 197             View.ValidateCleanEvent += View_ValidateCleanEvent;
 198             View.ValidateOpenEvent += View_ValidateOpenEvent;
 199             View.ValidateShowEvent += View_ValidateShowEvent;
 200         }
 201
 202         private void View_TrashEvent()
 203         {
 204             foreach (IProgressView progressView in View.SelectedTransfers)
 205             {
 206                 Transfer transfer = GetTransferFromView(progressView);
 207                 if (!transfer.isRunning())
 208                 {
 209                     for (int i = 0; i < transfer.getRoots().size(); i++)
 210                     {
 211                         TransferItem item = (TransferItem) transfer.getRoots().get(i);
 212                         try
 213                         {
 214                             LocalTrashFactory.get().trash(item.local);
 215                         }
 216                         catch (Exception exception)
 217                         {
 218                             Log.warn(String.Format("Failure trashing file {0} {1}", item.local, exception.Message));
 219                         }
 220                     }
 221                 }
 222             }
 223         }
 224
 225         private void View_TranscriptHeightChangedEvent()
 226         {
 227             PreferencesFactory.get().setProperty("queue.transcript.size.height", View.TranscriptHeight);
 228         }
 229
 230         private void View_ToggleTranscriptEvent()
 231         {
 232             View.TranscriptVisible = !View.TranscriptVisible;
 233             PreferencesFactory.get().setProperty("queue.transcript.open", View.TranscriptVisible);
 234         }
 235
 236         private bool View_ValidateShowEvent()
 237         {
 238             return ValidateToolbarItem(delegate(Transfer transfer)
 239             {
 240                 if (transfer.getLocal() != null)
 241                 {
 242                     for (int i = 0; i < transfer.getRoots().size(); i++)
 243                     {
 244                         TransferItem t = (TransferItem) transfer.getRoots().get(i);
 245                         if (t.local.exists())
 246                         {
 247                             return true;
 248                         }
 249                     }
 250                 }
 251                 return false;
 252             });
 253         }
 254
 255         private bool View_ValidateOpenEvent()
 256         {
 257             return ValidateToolbarItem(delegate(Transfer transfer)
 258             {
 259                 if (transfer.getLocal() != null)
 260                 {
 261                     if (!transfer.isComplete())
 262                     {
 263                         return false;
 264                     }
 265                     if (!transfer.isRunning())
 266                     {
 267                         for (int i = 0; i < transfer.getRoots().size(); i++)
 268                         {
 269                             TransferItem item = (TransferItem) transfer.getRoots().get(i);
 270                             if (item.local.exists())
 271                             {
 272                                 return true;
 273                             }
 274                         }
 275                     }
 276                 }
 277                 return false;
 278             });
 279         }
 280
 281         private bool View_ValidateCleanEvent()
 282         {
 283             return _transferMap.Count > 0;
 284         }
 285
 286         private void View_CleanEvent()
 287         {
 288             IList<Transfer> toRemove = new List<Transfer>();
 289             foreach (KeyValuePair<Transfer, ProgressController> pair in _transferMap)
 290             {
 291                 Transfer t = pair.Key;
 292                 if (!t.isRunning() && t.isComplete())
 293                 {
 294                     TransferCollection.defaultCollection().remove(t);
 295                     toRemove.Add(t);
 296                 }
 297             }
 298             foreach (Transfer t in toRemove)
 299             {
 300                 _transferMap.Remove(t);
 301             }
 302             TransferCollection.defaultCollection().save();
 303         }
 304
 305         private bool View_ValidateRemoveEvent()
 306         {
 307             return View.SelectedTransfers.Count > 0;
 308         }
 309
 310         private bool View_ValidateStopEvent()
 311         {
 312             return ValidateToolbarItem(transfer => transfer.isRunning());
 313         }
 314
 315         private bool View_ValidateReloadEvent()
 316         {
 317             return ValidateToolbarItem(transfer => (transfer.getType().isReloadable() && !transfer.isRunning()));
 318         }
 319
 320         /// <summary>
 321         /// Validates the selected items in the transfer window against the toolbar validator
 322         /// </summary>
 323         /// <param name="validate"></param>
 324         /// <returns>True if one or more of the selected items passes the validation test</returns>
 325         private bool ValidateToolbarItem(TransferToolbarValidator validate)
 326         {
 327             foreach (IProgressView selectedTransfer in View.SelectedTransfers)
 328             {
 329                 Transfer transfer = GetTransferFromView(selectedTransfer);
 330                 if (validate(transfer))
 331                 {
 332                     return true;
 333                 }
 334             }
 335             return false;
 336         }
 337
 338         private bool View_ValidateResumeEvent()
 339         {
 340             return ValidateToolbarItem(delegate(Transfer transfer)
 341             {
 342                 if (transfer.isRunning())
 343                 {
 344                     return false;
 345                 }
 346                 return !transfer.isComplete();
 347             });
 348         }
 349
 350         private void PopulateBandwithList()
 351         {
 352             IList<KeyValuePair<float, string>> list = new List<KeyValuePair<float, string>>();
 353             list.Add(new KeyValuePair<float, string>(BandwidthThrottle.UNLIMITED,
 354                 LocaleFactory.localizedString("Unlimited Bandwidth", "Preferences")));
 355             foreach (String option in
 356                 PreferencesFactory.get()
 357                     .getProperty("queue.bandwidth.options")
 358                     .Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries))
 359             {
 360                 list.Add(new KeyValuePair<float, string>(Convert.ToInt32(option.Trim()),
 361                     (SizeFormatterFactory.get(true).format(Convert.ToInt32(option.Trim())) + "/s")));
 362             }
 363             View.PopulateBandwidthList(list);
 364         }
 365
 366         private void View_QueueSizeChangedEvent()
 367         {
 368             PreferencesFactory.get().setProperty("queue.maxtransfers", View.QueueSize);
 369             QueueFactory.get().resize(PreferencesFactory.get().getInteger("queue.maxtransfers"));
 370         }
 371
 372         private void View_BandwidthChangedEvent()
 373         {
 374             foreach (IProgressView progressView in View.SelectedTransfers)
 375             {
 376                 Transfer transfer = GetTransferFromView(progressView);
 377                 transfer.setBandwidth(View.Bandwidth);
 378                 if (transfer.isRunning())
 379                 {
 380                     BackgroundActionRegistry registry = getActions();
 381                     // Find matching background task
 382                     for (int i = 0; i < registry.size(); i++)
 383                     {
 384                         if (registry.get(i) is TransferBackgroundAction)
 385                         {
 386                             TransferBackgroundAction t = (TransferBackgroundAction) registry.get(i);
 387                             if (t.getTransfer().Equals(transfer))
 388                             {
 389                                 TransferSpeedometer meter = t.getMeter();
 390                                 meter.reset();
 391                             }
 392                         }
 393                     }
 394                 }
 395             }
 396             UpdateBandwidthPopup();
 397         }
 398
 399         private void View_SelectionChangedEvent()
 400         {
 401             Log.debug("SelectionChanged");
 402             UpdateLabels();
 403             UpdateIcon();
 404             UpdateBandwidthPopup();
 405         }
 406
 407         private void UpdateBandwidthPopup()
 408         {
 409             Log.debug("UpdateBandwidthPopup");
 410             IList<IProgressView> selectedTransfers = View.SelectedTransfers;
 411             View.BandwidthEnabled = selectedTransfers.Count > 0;
 412
 413             foreach (IProgressView progressView in View.SelectedTransfers)
 414             {
 415                 Transfer transfer = GetTransferFromView(progressView);
 416                 if (transfer.getBandwidth().getRate() != BandwidthThrottle.UNLIMITED)
 417                 {
 418                     View.Bandwidth = transfer.getBandwidth().getRate();
 419                 }
 420                 else
 421                 {
 422                     View.Bandwidth = BandwidthThrottle.UNLIMITED;
 423                 }
 424                 return;
 425             }
 426         }
 427
 428         private void UpdateIcon()
 429         {
 430             IList<IProgressView> selectedTransfers = View.SelectedTransfers;
 431             if (1 == selectedTransfers.Count)
 432             {
 433                 Transfer transfer = GetTransferFromView(selectedTransfers[0]);
 434                 if (transfer.getRoots().size() == 1)
 435                 {
 436                     if (transfer.getLocal() != null)
 437                     {
 438                         View.FileIcon = IconCache.Instance.IconForFilename(transfer.getRoot().local.getAbsolute(),
 439                             IconCache.IconSize.Large);
 440                     }
 441                     else
 442                     {
 443                         View.FileIcon = IconCache.Instance.IconForPath(transfer.getRoot().remote,
 444                             IconCache.IconSize.Large);
 445                     }
 446                 }
 447                 else
 448                 {
 449                     View.FileIcon = ResourcesBundle.multiple.ToBitmap();
 450                 }
 451             }
 452             else
 453             {
 454                 View.FileIcon = null;
 455             }
 456         }
 457
 458         private void UpdateLabels()
 459         {
 460             IList<IProgressView> selectedTransfers = View.SelectedTransfers;
 461             if (1 == selectedTransfers.Count)
 462             {
 463                 Transfer transfer = GetTransferFromView(selectedTransfers[0]);
 464                 View.Url = transfer.getRemote().getUrl();
 465                 //Workaround to prevent NullReferenceException
 466                 if (transfer.getLocal() != null)
 467                 {
 468                     View.Local = transfer.getLocal();
 469                 }
 470                 else
 471                 {
 472                     View.Local = string.Empty;
 473                 }
 474             }
 475             else
 476             {
 477                 View.Url = string.Empty;
 478                 View.Local = string.Empty;
 479             }
 480         }
 481
 482         private void View_ShowEvent()
 483         {
 484             foreach (IProgressView progressView in View.SelectedTransfers)
 485             {
 486                 Transfer transfer = GetTransferFromView(progressView);
 487                 for (int i = 0; i < transfer.getRoots().size(); i++)
 488                 {
 489                     TransferItem item = (TransferItem) transfer.getRoots().get(i);
 490                     RevealServiceFactory.get().reveal(item.local);
 491                 }
 492             }
 493         }
 494
 495         private void View_OpenEvent()
 496         {
 497             IList<IProgressView> selected = View.SelectedTransfers;
 498             if (selected.Count == 1)
 499             {
 500                 Transfer transfer = GetTransferFromView(selected[0]);
 501
 502                 for (int i = 0; i < transfer.getRoots().size(); i++)
 503                 {
 504                     TransferItem item = (TransferItem) transfer.getRoots().get(i);
 505                     Local l = item.local;
 506                     if (ApplicationLauncherFactory.get().open(l))
 507                     {
 508                         break;
 509                     }
 510                 }
 511             }
 512         }
 513
 514         private void View_RemoveEvent()
 515         {
 516             foreach (IProgressView progressView in View.SelectedTransfers)
 517             {
 518                 Transfer transfer = GetTransferFromView(progressView);
 519                 if (!transfer.isRunning())
 520                 {
 521                     TransferCollection.defaultCollection().remove(transfer);
 522                 }
 523             }
 524             TransferCollection.defaultCollection().save();
 525         }
 526
 527         private void View_StopEvent()
 528         {
 529             foreach (IProgressView progressView in View.SelectedTransfers)
 530             {
 531                 Transfer transfer = GetTransferFromView(progressView);
 532                 BackgroundActionRegistry registry = getActions();
 533                 if (transfer.isRunning())
 534                 {
 535                     // Find matching background task
 536                     for (int i = 0; i < registry.size(); i++)
 537                     {
 538                         if (registry.get(i) is TransferBackgroundAction)
 539                         {
 540                             TransferBackgroundAction t = (TransferBackgroundAction) registry.get(i);
 541                             if (t.getTransfer().Equals(transfer))
 542                             {
 543                                 t.cancel();
 544                             }
 545                         }
 546                     }
 547                 }
 548             }
 549         }
 550
 551         private void View_ReloadEvent()
 552         {
 553             foreach (IProgressView progressView in View.SelectedTransfers)
 554             {
 555                 Transfer transfer = GetTransferFromView(progressView);
 556                 if (!transfer.isRunning())
 557                 {
 558                     TransferOptions options = new TransferOptions();
 559                     options.resumeRequested = false;
 560                     options.reloadRequested = true;
 561                     StartTransfer(transfer, options);
 562                 }
 563             }
 564         }
 565
 566         private Transfer GetTransferFromView(IProgressView view)
 567         {
 568             foreach (KeyValuePair<Transfer, ProgressController> pair in _transferMap)
 569             {
 570                 if (pair.Value.View == view) return pair.Key;
 571             }
 572             return null;
 573         }
 574
 575         private void View_ResumeEvent()
 576         {
 577             foreach (IProgressView progressView in View.SelectedTransfers)
 578             {
 579                 Transfer transfer = GetTransferFromView(progressView);
 580                 if (!transfer.isRunning())
 581                 {
 582                     TransferOptions options = new TransferOptions();
 583                     options.resumeRequested = true;
 584                     options.reloadRequested = false;
 585                     StartTransfer(transfer, options);
 586                 }
 587             }
 588         }
 589
 590         /// <summary>
 591         ///
 592         /// </summary>
 593         /// <param name="transfer"></param>
 594         public void StartTransfer(Transfer transfer)
 595         {
 596             StartTransfer(transfer, new TransferOptions());
 597         }
 598
 599         public void StartTransfer(Transfer transfer, TransferOptions options)
 600         {
 601             StartTransfer(transfer, options, new NoopTransferCallback());
 602         }
 603
 604         public void StartTransfer(Transfer transfer, TransferOptions options, TransferCallback callback)
 605         {
 606             if (!TransferCollection.defaultCollection().contains(transfer))
 607             {
 608                 TransferCollection.defaultCollection().add(transfer);
 609             }
 610             ProgressController progressController;
 611             _transferMap.TryGetValue(transfer, out progressController);
 612             background(new TransferBackgroundAction(this, transfer, options, callback));
 613         }
 614
 615         public void TaskbarOverlayIcon(Icon icon, string description)
 616         {
 617             Invoke(delegate { View.TaskbarOverlayIcon(icon, description); });
 618         }
 619
 620         private class LogAction : WindowMainAction
 621         {
 622             private readonly string _msg;
 623             private readonly bool _request;
 624
 625             public LogAction(TransferController c, bool request, string msg) : base(c)
 626             {
 627                 _request = request;
 628                 _msg = msg;
 629             }
 630
 631             public override void run()
 632             {
 633                 ((TransferController) Controller).View.AddTranscriptEntry(_request, _msg);
 634             }
 635         }
 636
 637         private class NoopTransferCallback : TransferCallback
 638         {
 639             public void complete(Transfer t)
 640             {
 641                 ;
 642             }
 643         }
 644
 645         private class TransferBackgroundAction : TransferCollectionBackgroundAction
 646         {
 647             private readonly TransferCallback _callback;
 648             private readonly TransferController _controller;
 649             private readonly Transfer _transfer;
 650
 651             public TransferBackgroundAction(TransferController controller, Transfer transfer, TransferOptions options,
 652                 TransferCallback callback)
 653                 : base(
 654                     controller,
 655                     SessionFactory.create(transfer.getHost(),
 656                         new KeychainX509TrustManager(new DefaultTrustManagerHostnameCallback(transfer.getHost())),
 657                         new KeychainX509KeyManager()), controller.GetController(transfer),
 658                     controller.GetController(transfer), controller, transfer, options)
 659             {
 660                 _transfer = transfer;
 661                 _callback = callback;
 662                 _controller = controller;
 663             }
 664
 665             public override void init()
 666             {
 667                 base.init();
 668                 if (PreferencesFactory.get().getBoolean("queue.window.open.transfer.start"))
 669                 {
 670                     _controller.View.Show();
 671                     _controller.View.BringToFront();
 672                 }
 673             }
 674
 675             public override void finish()
 676             {
 677                 base.finish();
 678                 if (_transfer.isComplete())
 679                 {
 680                     _callback.complete(_transfer);
 681                 }
 682             }
 683
 684             public override void cleanup()
 685             {
 686                 base.cleanup();
 687                 if (_transfer.isComplete() && _transfer.isReset())
 688                 {
 689                     if (PreferencesFactory.get().getBoolean("queue.window.open.transfer.stop"))
 690                     {
 691                         if (!(TransferCollection.defaultCollection().numberOfRunningTransfers() > 0))
 692                         {
 693                             _controller.View.Close();
 694                         }
 695                     }
 696                 }
 697             }
 698         }
 699
 700         private delegate bool TransferToolbarValidator(Transfer transfer);
 701     }
 702 }