/**
   * Remove an outstanding piece data request.
   *
   * @param piece_number
   * @param piece_offset
   * @param length
   */
  public void removePieceRequest(int piece_number, int piece_offset, int length) {
    if (destroyed) return;

    DiskManagerReadRequest dmr =
        peer.getManager().getDiskManager().createReadRequest(piece_number, piece_offset, length);

    try {
      lock_mon.enter();

      if (requests.contains(dmr)) {
        requests.remove(dmr);
        return;
      }

      if (loading_messages.contains(dmr)) {
        loading_messages.remove(dmr);
        return;
      }

      for (Iterator i = queued_messages.entrySet().iterator(); i.hasNext(); ) {
        Map.Entry entry = (Map.Entry) i.next();
        if (entry.getValue().equals(dmr)) { // it's already been queued
          BTPiece msg = (BTPiece) entry.getKey();
          if (outgoing_message_queue.removeMessage(msg, true)) {
            i.remove();
          }
          break; // do manual listener notify
        }
      }
    } finally {
      lock_mon.exit();
    }

    outgoing_message_queue.doListenerNotifications();
  }
 public void peerHasPiece(PEPeer peer) {
   try {
     class_mon.enter();
     // System.out.println("piece: #"+pieceNumber+" , old level:"+level+",
     // timeFirstDistributed:"+timeFirstDistributed+ "/
     // timetoreachanotherpeer:"+timeToReachAnotherPeer);
     if (level < 2) {
       // first time that somebody tells us this piece exists elsewhere
       // if peer=null, it is due to bitfield scan, so firstreceiver gets NULL
       firstReceiver = peer;
       timeFirstDistributed = SystemTime.getCurrentTime();
       // numberOfPeersWhenFirstReceived = manager.getNbPeers();
       level = 2;
     } else {
       // level=2 or 3 and we arrive here when somebody has got the piece, either BT_HAVE or
       // bitfield scan
       // if we are here due to bitfield scan, 'peer' = null --> do nothing
       // if level=2 --> mark piece redistributed, set speedstatus of firstreceiver, bump level to
       // 3
       // if level=3 --> this piece has been already seen at 3rd party earlier, do nothing
       if (peer != null && firstReceiver != null && level == 2) {
         timeToReachAnotherPeer = (int) (SystemTime.getCurrentTime() - timeFirstDistributed);
         firstReceiver.setUploadHint(timeToReachAnotherPeer);
         level = 3;
       }
     }
   } finally {
     class_mon.exit();
   }
 }
  public static void registerDecoders(Map _decoders) {
    try {
      class_mon.enter();

      Map new_decoders = new HashMap(packet_decoders);

      Iterator it = _decoders.keySet().iterator();

      while (it.hasNext()) {

        Integer action = (Integer) it.next();

        if (packet_decoders.containsKey(action)) {

          Debug.out("Duplicate codec! " + action);
        }
      }

      new_decoders.putAll(_decoders);

      packet_decoders = new_decoders;

    } finally {

      class_mon.exit();
    }
  }
        public void messageSent(Message message) {
          if (message.getID().equals(BTMessage.ID_BT_PIECE)) {
            try {
              lock_mon.enter();

              // due to timing issues we can get in here with a message already removed

              queued_messages.remove(message);

            } finally {
              lock_mon.exit();
            }

            /*
            if ( peer.getIp().equals( "64.71.5.2" )){

            	outgoing_message_queue.setTrace( true );

            	// BTPiece p = (BTPiece)message;

            	// TimeFormatter.milliTrace( "obt sent: " + p.getPieceNumber() + "/" + p.getPieceOffset());
            }
            */

            doReadAheadLoads();
          }
        }
示例#5
0
  public UPnPPluginService[] getServices(UPnPDevice device) {
    String target_usn = device.getRootDevice().getUSN();

    List<UPnPPluginService> res = new ArrayList<UPnPPluginService>();

    try {
      this_mon.enter();

      for (UPnPPluginService service : services) {

        String this_usn =
            service.getService().getGenericService().getDevice().getRootDevice().getUSN();

        if (this_usn.equals(target_usn)) {

          res.add(service);
        }
      }
    } finally {

      this_mon.exit();
    }

    return (res.toArray(new UPnPPluginService[res.size()]));
  }
  public void unregister(PeerControlInstance instance) {
    try {
      this_mon.enter();

      Map<PeerControlInstance, instanceWrapper> new_map =
          new HashMap<PeerControlInstance, instanceWrapper>(instance_map);

      instanceWrapper wrapper = new_map.remove(instance);

      if (wrapper == null) {

        Debug.out("instance wrapper not found");

        return;
      }

      wrapper.unregister();

      instance_map = new_map;

      registrations_changed = true;

    } finally {

      this_mon.exit();
    }
  }
示例#7
0
  public String[] getExternalIPAddresses() {
    List res = new ArrayList();

    try {
      this_mon.enter();

      for (int j = 0; j < services.size(); j++) {

        UPnPPluginService service = (UPnPPluginService) services.get(j);

        try {
          String address = service.getService().getExternalIPAddress();

          if (address != null) {

            res.add(address);
          }
        } catch (Throwable e) {

          Debug.printStackTrace(e);
        }
      }
    } finally {

      this_mon.exit();
    }

    return ((String[]) res.toArray(new String[res.size()]));
  }
  protected boolean checkConnectionId(String client_address, long id) {
    try {
      random_mon.enter();

      Long key = new Long(id);

      connectionData data = (connectionData) connection_id_map.get(key);

      if (data == null) {

        // System.out.println( "TRTrackerServerProcessorUDP: rejected:" + id + ", data not found" );

        return (false);

      } else {

        if (SystemTime.getMonotonousTime() - data.getTime() > CONNECTION_ID_LIFETIME) {

          return (false);
        }
      }

      boolean ok = data.getAddress().equals(client_address);

      // System.out.println( "TRTrackerServerProcessorUDP: tested:" + id + "/" + client_address + "
      // -> " + ok );

      return (ok);

    } finally {

      random_mon.exit();
    }
  }
示例#9
0
  /**
   * Add the given entity to the controller for read processing.
   *
   * @param entity to process reads for
   */
  public void addReadEntity(RateControlledEntity entity) {
    try {
      entities_mon.enter();
      if (entity.getPriority() == RateControlledEntity.PRIORITY_HIGH) {
        // copy-on-write
        ArrayList<RateControlledEntity> high_new =
            new ArrayList<RateControlledEntity>(high_priority_entities.size() + 1);
        high_new.addAll(high_priority_entities);
        high_new.add(entity);
        high_priority_entities = high_new;
      } else {
        // copy-on-write
        ArrayList<RateControlledEntity> norm_new =
            new ArrayList<RateControlledEntity>(normal_priority_entities.size() + 1);
        norm_new.addAll(normal_priority_entities);
        norm_new.add(entity);
        normal_priority_entities = norm_new;
      }

      entity_count = normal_priority_entities.size() + high_priority_entities.size();
    } finally {
      entities_mon.exit();
    }

    read_waiter.eventOccurred();
  }
示例#10
0
  public void setStorageType(int new_type) throws FMFileManagerException {

    try {
      this_mon.enter();

      boolean was_open = isOpen();

      if (was_open) {

        closeSupport(false);
      }

      try {
        file_access.setStorageType(new_type);

      } finally {

        if (was_open) {

          openSupport("Re-open after storage type change");
        }
      }

    } finally {

      this_mon.exit();
    }
  }
  private void doReadAheadLoads() {
    List to_submit = null;
    try {
      lock_mon.enter();

      while (loading_messages.size() + queued_messages.size() < request_read_ahead
          && !requests.isEmpty()
          && !destroyed) {
        DiskManagerReadRequest dmr = (DiskManagerReadRequest) requests.removeFirst();
        loading_messages.add(dmr);
        if (to_submit == null) to_submit = new ArrayList();
        to_submit.add(dmr);
      }
    } finally {
      lock_mon.exit();
    }

    /*
    if ( peer.getIp().equals( "64.71.5.2")){

    	TimeFormatter.milliTrace( "obt read_ahead: -> " + (to_submit==null?0:to_submit.size()) +
    			" [lo=" + loading_messages.size() + ",qm=" + queued_messages.size() + ",re=" + requests.size() + ",rl=" + request_read_ahead + "]");
    }
    */

    if (to_submit != null) {
      for (int i = 0; i < to_submit.size(); i++) {
        peer.getManager()
            .getAdapter()
            .enqueueReadRequest(peer, (DiskManagerReadRequest) to_submit.get(i), read_req_listener);
      }
    }
  }
示例#12
0
文件: Test.java 项目: aprasa/oldwork
  public static Test getSingleton() {
    try {
      class_mon.enter();

      if (singleton == null) {

        new AEThread("plugin initialiser") {
          public void runSupport() {
            PluginManager.registerPlugin(Test.class);

            Properties props = new Properties();

            props.put(PluginManager.PR_MULTI_INSTANCE, "true");

            PluginManager.startAzureus(PluginManager.UI_SWT, props);
          }
        }.start();

        init_sem.reserve();
      }

      return (singleton);

    } finally {

      class_mon.exit();
    }
  }
  /** Destroy the aggregator, along with any pending messages. */
  public void destroy() {
    try {
      pending_haves_mon.enter();

      pending_haves.clear();
      destroyed = true;
    } finally {
      pending_haves_mon.exit();
    }
  }
  public void pieceRevealedToPeer() {
    try {
      class_mon.enter();

      level = 1;
    } finally {

      class_mon.exit();
    }
  }
  public void removeListener(TableStructureModificationListener listener) {
    try {
      listeners_mon.enter();

      listeners.remove(listener);
    } finally {

      listeners_mon.exit();
    }
  }
  public static void removeListener(TRTrackerServerFactoryListener l) {
    try {
      class_mon.enter();

      listeners.remove(l);

    } finally {

      class_mon.exit();
    }
  }
示例#17
0
  public UPnPPluginService[] getServices() {
    try {
      this_mon.enter();

      return ((UPnPPluginService[]) services.toArray(new UPnPPluginService[services.size()]));

    } finally {

      this_mon.exit();
    }
  }
  public PasswordAuthentication getAuthentication(String realm, URL tracker) {
    try {
      this_mon.enter();

      return (getAuthentication(
          realm, tracker.getProtocol(), tracker.getHost(), tracker.getPort()));

    } finally {

      this_mon.exit();
    }
  }
  public void setAuthenticationOutcome(String realm, URL tracker, boolean success) {
    try {
      this_mon.enter();

      setAuthenticationOutcome(
          realm, tracker.getProtocol(), tracker.getHost(), tracker.getPort(), success);

    } finally {

      this_mon.exit();
    }
  }
示例#20
0
  protected static void generateEvidence(IndentWriter writer) {
    writer.println(file_map.size() + " FMFile Reservations");

    try {
      writer.indent();

      try {
        file_map_mon.enter();

        Iterator it = file_map.keySet().iterator();

        while (it.hasNext()) {

          String key = (String) it.next();

          List owners = (List) file_map.get(key);

          Iterator it2 = owners.iterator();

          String str = "";

          while (it2.hasNext()) {

            Object[] entry = (Object[]) it2.next();

            FMFileOwner owner = (FMFileOwner) entry[0];
            Boolean write = (Boolean) entry[1];
            String reason = (String) entry[2];

            str +=
                (str.length() == 0 ? "" : ", ")
                    + owner.getName()
                    + "["
                    + (write.booleanValue() ? "write" : "read")
                    + "/"
                    + reason
                    + "]";
          }

          writer.println(Debug.secretFileName(key) + " -> " + str);
        }
      } finally {

        file_map_mon.exit();
      }

      FMFileManagerImpl.generateEvidence(writer);

    } finally {

      writer.exdent();
    }
  }
  public void addListener(TableStructureModificationListener listener) {
    try {
      listeners_mon.enter();

      if (!listeners.contains(listener)) {
        listeners.add(listener);
      }

    } finally {

      listeners_mon.exit();
    }
  }
  public void clearPasswords() {
    try {
      this_mon.enter();

      auth_cache = new HashMap();

      saveAuthCache();

    } finally {

      this_mon.exit();
    }
  }
  private void error(int errCode, String err) {
    try {
      this_mon.enter(); // what's the point of this?

      this.state = STATE_ERROR;
      this.setError(errCode, err);
      this.cleanUpFile();
      this.notifyListener();
    } finally {

      this_mon.exit();
    }
  }
        public void readFailed(DiskManagerReadRequest request, Throwable cause) {
          try {
            lock_mon.enter();

            if (!loading_messages.contains(request) || destroyed) { // was canceled
              return;
            }
            loading_messages.remove(request);

          } finally {
            lock_mon.exit();
          }
        }
示例#25
0
  private void reserveFile() throws FMFileManagerException {

    if (clone) {

      return;
    }

    try {
      file_map_mon.enter();

      // System.out.println( "FMFile::reserveFile:" + canonical_path + "("+ owner.getName() + ")" +
      // " - " + Debug.getCompressedStackTrace() );

      List owners = (List) file_map.get(canonical_path);

      if (owners == null) {

        owners = new ArrayList();

        // System.out.println( "    creating new owners entr" );

        file_map.put(canonical_path, owners);
      }

      for (Iterator it = owners.iterator(); it.hasNext(); ) {

        Object[] entry = (Object[]) it.next();

        String entry_name = ((FMFileOwner) entry[0]).getName();

        // System.out.println( "    existing entry: " + entry_name );

        if (owner.getName().equals(entry_name)) {

          // already present, start off read-access

          Debug.out("reserve file - entry already present");

          entry[1] = new Boolean(false);

          return;
        }
      }

      owners.add(new Object[] {owner, new Boolean(false), "<reservation>"});

    } finally {

      file_map_mon.exit();
    }
  }
  public static TableStructureEventDispatcher getInstance(String tableID) {
    try {
      class_mon.enter();

      TableStructureEventDispatcher instance = instances.get(tableID);
      if (instance == null) {
        instance = new TableStructureEventDispatcher();
        instances.put(tableID, instance);
      }
      return instance;
    } finally {

      class_mon.exit();
    }
  }
 void removeListener(Object o) {
   boolean unregister_from_downloads = false;
   try {
     this_mon.enter();
     ArrayList new_listeners = new ArrayList(listeners);
     new_listeners.remove(o);
     this.listeners = new_listeners;
     unregister_from_downloads = this.listeners.isEmpty();
   } finally {
     this_mon.exit();
   }
   if (unregister_from_downloads) {
     dm.removeListener(this, true);
   }
 }
 void addListener(Object o) {
   boolean register_with_downloads = false;
   try {
     this_mon.enter();
     register_with_downloads = listeners.isEmpty();
     ArrayList new_listeners = new ArrayList(listeners);
     new_listeners.add(o);
     this.listeners = new_listeners;
   } finally {
     this_mon.exit();
   }
   if (register_with_downloads) {
     dm.addListener(this, true);
   }
 }
  public static ConfigurationManager getInstance(Map data) {
    try {
      class_mon.enter();

      if (config == null) {

        config = new ConfigurationManager(data);
      }

      return config;
    } finally {

      class_mon.exit();
    }
  }
  public void destroy() {
    try {
      lock_mon.enter();

      removeAllPieceRequests();

      queued_messages.clear();

      destroyed = true;

      outgoing_message_queue.cancelQueueListener(sent_message_listener);
    } finally {
      lock_mon.exit();
    }
  }