Esempio n. 1
0
  protected void fireChanged() {
    List<DeviceListener> l;

    synchronized (this) {
      if (device_listeners != null) {

        l = device_listeners.getList();

      } else {

        return;
      }
    }

    for (DeviceListener listener : l) {

      try {
        listener.deviceChanged(this);

      } catch (Throwable e) {

        Debug.out(e);
      }
    }
  }
  public void update(boolean force) {
    List<TRTrackerAnnouncerHelper> to_update;

    synchronized (this) {
      to_update =
          is_manual ? announcers.getList() : new ArrayList<TRTrackerAnnouncerHelper>(activated);
    }

    for (TRTrackerAnnouncer announcer : to_update) {

      announcer.update(force);
    }
  }
  public void setAnnounceDataProvider(TRTrackerAnnouncerDataProvider _provider) {
    List<TRTrackerAnnouncerHelper> to_set;

    synchronized (this) {
      provider = _provider;

      to_set = announcers.getList();
    }

    for (TRTrackerAnnouncer announcer : to_set) {

      announcer.setAnnounceDataProvider(provider);
    }
  }
  public void clearIPOverride() {
    List<TRTrackerAnnouncerHelper> to_clear;

    synchronized (this) {
      to_clear = announcers.getList();

      ip_override = null;
    }

    for (TRTrackerAnnouncer announcer : to_clear) {

      announcer.clearIPOverride();
    }
  }
  public void setIPOverride(String override) {
    List<TRTrackerAnnouncerHelper> to_set;

    synchronized (this) {
      to_set = announcers.getList();

      ip_override = override;
    }

    for (TRTrackerAnnouncer announcer : to_set) {

      announcer.setIPOverride(override);
    }
  }
  public void complete(boolean already_reported) {
    List<TRTrackerAnnouncerHelper> to_complete;

    synchronized (this) {
      complete = true;

      to_complete =
          is_manual ? announcers.getList() : new ArrayList<TRTrackerAnnouncerHelper>(activated);
    }

    for (TRTrackerAnnouncer announcer : to_complete) {

      announcer.complete(already_reported);
    }
  }
  public void stop(boolean for_queue) {
    List<TRTrackerAnnouncerHelper> to_stop;

    synchronized (this) {
      stopped = true;

      to_stop =
          is_manual ? announcers.getList() : new ArrayList<TRTrackerAnnouncerHelper>(activated);

      activated.clear();
    }

    for (TRTrackerAnnouncer announcer : to_stop) {

      announcer.stop(for_queue);
    }
  }
  public void destroy() {
    TRTrackerAnnouncerFactoryImpl.destroy(this);

    List<TRTrackerAnnouncerHelper> to_destroy;

    synchronized (this) {
      destroyed = true;

      to_destroy = announcers.getList();
    }

    for (TRTrackerAnnouncer announcer : to_destroy) {

      announcer.destroy();
    }

    TimerEvent ev = event;

    if (ev != null) {

      ev.cancel();
    }
  }
  protected TRTrackerAnnouncerHelper getBestActiveSupport() {
    List<TRTrackerAnnouncerHelper> x = announcers.getList();

    TRTrackerAnnouncerHelper error_resp = null;

    for (TRTrackerAnnouncerHelper announcer : x) {

      TRTrackerAnnouncerResponse response = announcer.getLastResponse();

      if (response != null) {

        int resp_status = response.getStatus();

        if (resp_status == TRTrackerAnnouncerResponse.ST_ONLINE) {

          return (announcer);

        } else if (error_resp == null
            && resp_status == TRTrackerAnnouncerResponse.ST_REPORTED_ERROR) {

          error_resp = announcer;
        }
      }
    }

    if (error_resp != null) {

      return (error_resp);
    }

    if (x.size() > 0) {

      return (x.get(0));
    }

    return (null);
  }
  public void setAnnounceResult(DownloadAnnounceResult result) {
    // this is only used for setting DHT results

    for (TRTrackerAnnouncer announcer : announcers) {

      if (announcer instanceof TRTrackerDHTAnnouncerImpl) {

        announcer.setAnnounceResult(result);

        return;
      }
    }

    // TODO: we should always create a DHT entry and have it denote DHT tracking for all
    // circustances
    // have the DHT plugin set it to offline if disabled

    List<TRTrackerAnnouncerHelper> x = announcers.getList();

    if (x.size() > 0) {

      x.get(0).setAnnounceResult(result);
    }
  }
  protected void split() throws TRTrackerAnnouncerException {

    String[] networks = f_provider == null ? null : f_provider.getNetworks();

    TRTrackerAnnouncerHelper to_activate = null;

    synchronized (this) {
      if (stopped || destroyed) {

        return;
      }

      TOTorrent torrent = getTorrent();

      TOTorrentAnnounceURLSet[] sets = torrent.getAnnounceURLGroup().getAnnounceURLSets();

      // sanitise dht entries

      if (sets.length == 0) {

        sets =
            new TOTorrentAnnounceURLSet[] {
              torrent
                  .getAnnounceURLGroup()
                  .createAnnounceURLSet(new URL[] {torrent.getAnnounceURL()})
            };

      } else {

        boolean found_decentralised = false;
        boolean modified = false;

        for (int i = 0; i < sets.length; i++) {

          TOTorrentAnnounceURLSet set = sets[i];

          URL[] urls = set.getAnnounceURLs().clone();

          for (int j = 0; j < urls.length; j++) {

            URL u = urls[j];

            if (u != null && TorrentUtils.isDecentralised(u)) {

              if (found_decentralised) {

                modified = true;

                urls[j] = null;

              } else {

                found_decentralised = true;
              }
            }
          }
        }

        if (modified) {

          List<TOTorrentAnnounceURLSet> s_list = new ArrayList<TOTorrentAnnounceURLSet>();

          for (TOTorrentAnnounceURLSet set : sets) {

            URL[] urls = set.getAnnounceURLs();

            List<URL> u_list = new ArrayList<URL>(urls.length);

            for (URL u : urls) {

              if (u != null) {

                u_list.add(u);
              }
            }

            if (u_list.size() > 0) {

              s_list.add(
                  torrent
                      .getAnnounceURLGroup()
                      .createAnnounceURLSet(u_list.toArray(new URL[u_list.size()])));
            }
          }

          sets = s_list.toArray(new TOTorrentAnnounceURLSet[s_list.size()]);
        }
      }

      List<TOTorrentAnnounceURLSet[]> new_sets = new ArrayList<TOTorrentAnnounceURLSet[]>();

      if (is_manual || sets.length < 2) {

        new_sets.add(sets);

      } else {

        List<TOTorrentAnnounceURLSet> list =
            new ArrayList<TOTorrentAnnounceURLSet>(Arrays.asList(sets));

        // often we have http:/xxxx/ and udp:/xxxx/ as separate groups - keep these together

        while (list.size() > 0) {

          TOTorrentAnnounceURLSet set1 = list.remove(0);

          boolean done = false;

          URL[] urls1 = set1.getAnnounceURLs();

          if (urls1.length == 1) {

            URL url1 = urls1[0];

            String prot1 = url1.getProtocol().toLowerCase();
            String host1 = url1.getHost();

            for (int i = 0; i < list.size(); i++) {

              TOTorrentAnnounceURLSet set2 = list.get(i);

              URL[] urls2 = set2.getAnnounceURLs();

              if (urls2.length == 1) {

                URL url2 = urls2[0];

                String prot2 = url2.getProtocol().toLowerCase();
                String host2 = url2.getHost();

                if (host1.equals(host2)) {

                  if ((prot1.equals("udp") && prot2.startsWith("http"))
                      || (prot2.equals("udp") && prot1.startsWith("http"))) {

                    list.remove(i);

                    new_sets.add(new TOTorrentAnnounceURLSet[] {set1, set2});

                    done = true;
                  }
                }
              }
            }
          }

          if (!done) {

            new_sets.add(new TOTorrentAnnounceURLSet[] {set1});
          }
        }
      }

      // work out the difference

      Iterator<TOTorrentAnnounceURLSet[]> ns_it = new_sets.iterator();

      // need to copy list as we modify it and returned list ain't thread safe

      List<TRTrackerAnnouncerHelper> existing_announcers =
          new ArrayList<TRTrackerAnnouncerHelper>(announcers.getList());

      List<TRTrackerAnnouncerHelper> new_announcers = new ArrayList<TRTrackerAnnouncerHelper>();

      // first look for unchanged sets

      while (ns_it.hasNext()) {

        TOTorrentAnnounceURLSet[] ns = ns_it.next();

        Iterator<TRTrackerAnnouncerHelper> a_it = existing_announcers.iterator();

        while (a_it.hasNext()) {

          TRTrackerAnnouncerHelper a = a_it.next();

          TOTorrentAnnounceURLSet[] os = a.getAnnounceSets();

          if (same(ns, os)) {

            ns_it.remove();
            a_it.remove();

            new_announcers.add(a);

            break;
          }
        }
      }

      // reuse existing announcers

      // first remove dht ones from the equation

      TRTrackerAnnouncerHelper existing_dht_announcer = null;
      TOTorrentAnnounceURLSet[] new_dht_set = null;

      ns_it = new_sets.iterator();

      while (ns_it.hasNext()) {

        TOTorrentAnnounceURLSet[] x = ns_it.next();

        if (TorrentUtils.isDecentralised(x[0].getAnnounceURLs()[0])) {

          new_dht_set = x;

          ns_it.remove();

          break;
        }
      }

      Iterator<TRTrackerAnnouncerHelper> an_it = existing_announcers.iterator();

      while (an_it.hasNext()) {

        TRTrackerAnnouncerHelper a = an_it.next();

        TOTorrentAnnounceURLSet[] x = a.getAnnounceSets();

        if (TorrentUtils.isDecentralised(x[0].getAnnounceURLs()[0])) {

          existing_dht_announcer = a;

          an_it.remove();

          break;
        }
      }

      if (existing_dht_announcer != null && new_dht_set != null) {

        new_announcers.add(existing_dht_announcer);

      } else if (existing_dht_announcer != null) {

        activated.remove(existing_dht_announcer);

        existing_dht_announcer.destroy();

      } else if (new_dht_set != null) {

        TRTrackerAnnouncerHelper a = create(torrent, networks, new_dht_set);

        new_announcers.add(a);
      }

      // now do the non-dht ones

      ns_it = new_sets.iterator();

      while (ns_it.hasNext() && existing_announcers.size() > 0) {

        TRTrackerAnnouncerHelper a = existing_announcers.remove(0);

        TOTorrentAnnounceURLSet[] s = ns_it.next();

        ns_it.remove();

        if (activated.contains(a)
            && torrent.getPrivate()
            && a instanceof TRTrackerBTAnnouncerImpl) {

          URL url = a.getTrackerURL();

          if (url != null) {

            forceStop((TRTrackerBTAnnouncerImpl) a, networks, url);
          }
        }

        a.setAnnounceSets(s, networks);

        new_announcers.add(a);
      }

      // create any new ones required

      ns_it = new_sets.iterator();

      while (ns_it.hasNext()) {

        TOTorrentAnnounceURLSet[] s = ns_it.next();

        TRTrackerAnnouncerHelper a = create(torrent, networks, s);

        new_announcers.add(a);
      }

      // finally fix up the announcer list to represent the new state

      Iterator<TRTrackerAnnouncerHelper> a_it = announcers.iterator();

      while (a_it.hasNext()) {

        TRTrackerAnnouncerHelper a = a_it.next();

        if (!new_announcers.contains(a)) {

          a_it.remove();

          try {
            if (activated.contains(a)
                && torrent.getPrivate()
                && a instanceof TRTrackerBTAnnouncerImpl) {

              URL url = a.getTrackerURL();

              if (url != null) {

                forceStop((TRTrackerBTAnnouncerImpl) a, networks, url);
              }
            }
          } finally {

            if (Logger.isEnabled()) {
              Logger.log(
                  new LogEvent(
                      getTorrent(), LOGID, "Deactivating " + getString(a.getAnnounceSets())));
            }

            activated.remove(a);

            a.destroy();
          }
        }
      }

      a_it = new_announcers.iterator();

      while (a_it.hasNext()) {

        TRTrackerAnnouncerHelper a = a_it.next();

        if (!announcers.contains(a)) {

          announcers.add(a);
        }
      }

      if (!is_manual && announcers.size() > 0) {

        if (activated.size() == 0) {

          TRTrackerAnnouncerHelper a = announcers.get(0);

          if (Logger.isEnabled()) {
            Logger.log(
                new LogEvent(getTorrent(), LOGID, "Activating " + getString(a.getAnnounceSets())));
          }

          activated.add(a);

          last_activation_time = SystemTime.getMonotonousTime();

          if (provider != null) {

            to_activate = a;
          }
        }

        setupActivationCheck(ACT_CHECK_INIT_DELAY);
      }
    }

    if (to_activate != null) {

      if (complete) {

        to_activate.complete(true);

      } else {

        to_activate.update(false);
      }
    }
  }