Package org.gudy.azureus2.core3.disk.impl.piecemapper

Examples of org.gudy.azureus2.core3.disk.impl.piecemapper.DMPieceList


    DownloadManager dm = (DownloadManager) ds;
    if (rowCore.getSubItemCount() == 0 && dm.getTorrent() != null
        && !dm.getTorrent().isSimpleTorrent() && rowCore.isVisible()
        && dm.getNumFileInfos() > 0) {
      DiskManagerFileInfoSet fileInfos = dm.getDiskManagerFileInfoSet();
      if (fileInfos != null) {
        DiskManagerFileInfo[] files = fileInfos.getFiles();
        boolean copied = false;
        int pos = 0;
        for (int i = 0; i < files.length; i++) {
          DiskManagerFileInfo fileInfo = files[i];
          if (fileInfo.isSkipped()
View Full Code Here


  public static DiskManager
  create(
    TOTorrent    torrent,
    DownloadManager manager)
  {
    DiskManagerImpl dm = new DiskManagerImpl( torrent, manager );
   
    if ( dm.getState() != DiskManager.FAULTY ){
     
      dm.start();
    }
   
    return dm;
  }
View Full Code Here

             
              piece.setDone( passed );
             
              if ( passed ){
               
                DMPieceList  piece_list = disk_manager.getPieceList( piece_number );
               
                for (int i = 0; i < piece_list.size(); i++) {
                 
                  DMPieceMapEntry piece_entry = piece_list.get(i);
                   
                  piece_entry.getFile().dataChecked( piece_entry.getOffset(), piece_entry.getLength());
                }
              }
            }finally{
View Full Code Here

        // fail as we don't actually have any data for the piece (or can assume we don't)
        // we relax this a bit to catch pieces that are part of compact files with less than
        // three pieces as it is possible that these were once complete and have all their bits
        // living in retained compact areas
     
      final DMPieceList pieceList = disk_manager.getPieceList(pieceNumber);

      try{
          // there are other comments in the code about the existence of 0 length piece lists
          // just in case these still occur for who knows what reason ensure that a 0 length list
          // causes the code to carry on and do the check (i.e. it is no worse that before this
          // optimisation was added...)
       
        boolean  all_compact = pieceList.size() > 0;
       
        for (int i = 0; i < pieceList.size(); i++) {
         
          DMPieceMapEntry piece_entry = pieceList.get(i);
           
          DiskManagerFileInfoImpl  file_info = piece_entry.getFile();
         
          CacheFile  cache_file = file_info.getCacheFile();
         
          if ( cache_file.compareLength( piece_entry.getOffset()) < 0 ){
             
            listener.checkCompleted( request, false );
           
            return;
          }
         
          if ( all_compact ){
           
            int st = cache_file.getStorageType();
           
            if (( st != CacheFile.CT_COMPACT && st != CacheFile.CT_PIECE_REORDER_COMPACT ) || file_info.getNbPieces() <= 2 ){
                   
              all_compact = false;
            }
          }
        }
       
        if ( all_compact ){
       
            // System.out.println( "Piece " + pieceNumber + " is all compact, failing hash check" );
         
          listener.checkCompleted( request, false );
         
          return;
        }
       
      }catch( Throwable e ){
     
          // we can fail here if the disk manager has been stopped as the cache file length access may be being
          // performed on a "closed" (i.e. un-owned) file
       
        listener.checkCancelled( request );

        return;
      }
     
      int this_piece_length = disk_manager.getPieceLength( pieceNumber );

      DiskManagerReadRequest read_request = disk_manager.createReadRequest( pieceNumber, 0, this_piece_length );
     
         try{
           this_mon.enter();
        
        if ( stopped ){
         
          listener.checkCancelled( request );
         
          return;
        }
       
        async_reads++;
          
         }finally{
          
           this_mon.exit();
         }
        
         read_request.setFlush( read_flush );
        
         read_request.setUseCache( !request.isAdHoc());
        
      disk_manager.enqueueReadRequest(
        read_request,
        new DiskManagerReadRequestListener()
        {
          public void
          readCompleted(
            DiskManagerReadRequest   read_request,
            DirectByteBuffer     buffer )
          {
            complete();
           
               try{
                 this_mon.enter();
              
              if ( stopped ){
               
                buffer.returnToPool();
               
                listener.checkCancelled( request );
               
                return;
              }
             
              async_checks++;
                
               }finally{
                
                 this_mon.exit();
               }
           
            try{
                final  DirectByteBuffer  f_buffer  = buffer;
               
                 ConcurrentHasher.getSingleton().addRequest(
                    buffer.getBuffer(DirectByteBuffer.SS_DW),
                  new ConcurrentHasherRequestListener()
                  {
                      public void
                    complete(
                      ConcurrentHasherRequest  hash_request )
                      {
                        int  async_result  = 3; // cancelled
                                               
                        try{
                         
                        byte[] actual_hash = hash_request.getResult();
                                               
                        if ( actual_hash != null ){
                           
                          request.setHash( actual_hash );
                         
                            async_result = 1; // success
                           
                            for (int i = 0; i < actual_hash.length; i++){
                             
                              if ( actual_hash[i] != required_hash[i]){
                               
                                async_result = 2; // failed;
                               
                                break;
                              }
                            }
                        }
                        }finally{
                         
                          try{
                            if ( async_result == 1 ){
                           
                              try{
                                for (int i = 0; i < pieceList.size(); i++) {
                                 
                                  DMPieceMapEntry piece_entry = pieceList.get(i);
                                   
                                  DiskManagerFileInfoImpl  file_info = piece_entry.getFile();
                                 
                                    // edge case here for skipped zero length files that have been deleted
                                 
View Full Code Here

           
            if ( piece_state == PIECE_DONE || !resumeValid || recheck_all ){
           
                // at least check that file sizes are OK for this piece to be valid
             
              DMPieceList list = disk_manager.getPieceList(i);
             
              for (int j=0;j<list.size();j++){
               
                DMPieceMapEntry  entry = list.get(j);
               
                Long  file_size     = (Long)file_sizes.get(entry.getFile());
               
                if ( file_size == null ){
                 
                  piece_state  = PIECE_NOT_DONE;
                  pieceCannotExist = true;
                 
                  if (Logger.isEnabled())
                    Logger.log(new LogEvent(disk_manager, LOGID,
                        LogEvent.LT_WARNING, "Piece #" + i
                            + ": file is missing, " + "fails re-check."));
 
                  break;
                }
               
                long  expected_size   = entry.getOffset() + entry.getLength();
               
                if ( file_size.longValue() < expected_size ){
                 
                  piece_state  = PIECE_NOT_DONE;
                  pieceCannotExist = true;
                 
                  if (Logger.isEnabled())
                    Logger.log(new LogEvent(disk_manager, LOGID,
                        LogEvent.LT_WARNING, "Piece #" + i
                            + ": file is too small, fails re-check. File size = "
                            + file_size + ", piece needs " + expected_size));
 
                  break;
                }
              }
            }
           
            if ( piece_state == PIECE_DONE ){
             
              dm_piece.setDone( true );
             
            }else if ( piece_state == PIECE_NOT_DONE && !recheck_all ){
             
                // if the piece isn't done and we haven't been asked to recheck all pieces
                // on restart (only started pieces) then just set as not done
                                   
            }else{
             
                // We only need to recheck pieces that are marked as not-ok
                // if the resume data is invalid or explicit recheck needed
              if(pieceCannotExist)
              {
                dm_piece.setDone( false );
              } else if ( piece_state == PIECE_RECHECK_REQUIRED || !resumeValid ){
                   
                run_sem.reserve();
               
                while( !stopped ){
                   
                  if ( recheck_inst.getPermission()){
                   
                    break;
                  }
                }
               
                if ( stopped ){
                                   
                  break;
                 
                }else{
                 
                  try
                    DiskManagerCheckRequest  request = disk_manager.createCheckRequest( i, null );
                   
                    request.setLowPriority( true );
                   
                    checker.enqueueCheckRequest(
                      request,
                      new DiskManagerCheckRequestListener()
                      {
                        public void
                        checkCompleted(
                          DiskManagerCheckRequest   request,
                          boolean            passed )
                        {
                          if ( TEST_RECHECK_FAILURE_HANDLING && (int)(Math.random()*10) == 0 ){
                           
                            disk_manager.getPiece(request.getPieceNumber()).setDone(false);
                           
                            passed  = false;
                          }
                         
                          if ( !passed ){
                           
                            synchronized( failed_pieces ){
                           
                              failed_pieces.add( request );
                            }
                          }
                         
                          complete();
                        }
                        
                        public void
                        checkCancelled(
                          DiskManagerCheckRequest    request )
                        {
                          complete();
                        }
                       
                        public void
                        checkFailed(
                          DiskManagerCheckRequest   request,
                          Throwable           cause )
                        {
                          complete();
                        }
                       
                        protected void
                        complete()
                        {
                          run_sem.release();
                         
                          pending_checks_sem.release();
                        }
                      });
                   
                    pending_check_num++;
                   
                  }catch( Throwable e ){
                 
                    Debug.printStackTrace(e);
                  }
                }
              }
            }
          }
         
          while( pending_check_num > 0 ){
           
            pending_checks_sem.reserve();
           
            pending_check_num--;
          }
         
          if ( partialPieces != null ){
                             
            Iterator iter = partialPieces.entrySet().iterator();
           
            while (iter.hasNext()) {
             
              Map.Entry key = (Map.Entry)iter.next();
             
              int pieceNumber = Integer.parseInt((String)key.getKey());
               
              DiskManagerPiece  dm_piece = pieces[ pieceNumber ];
             
              if ( !dm_piece.isDone()){
               
                List blocks = (List)partialPieces.get(key.getKey());
               
                Iterator iterBlock = blocks.iterator();
               
                while (iterBlock.hasNext()) {
                 
                  dm_piece.setWritten(((Long)iterBlock.next()).intValue());
                }
              }
            }
          }
        }else{
         
          // resume not enabled, recheck everything
         
          for (int i = 0; i < pieces.length; i++){
 
            check_position  = i;
           
            disk_manager.setPercentDone(((i + 1) * 1000) / disk_manager.getNbPieces() );

            boolean pieceCannotExist = false;
           
            // check if there is an underlying file for this piece, if not set it to not done
            DMPieceList list = disk_manager.getPieceList(i);
           
            for (int j=0;j<list.size();j++){
              DMPieceMapEntry  entry = list.get(j);
             
              Long  file_size     = (Long)file_sizes.get(entry.getFile());
              if ( file_size == null ){
                pieceCannotExist = true;
                break;
View Full Code Here

       
        int previousFilesLength = 0;
       
        int currentFile = 0;
       
        DMPieceList pieceList = disk_manager.getPieceList(pieceNumber);
       
        DMPieceMapEntry current_piece = pieceList.get(currentFile);
       
        long fileOffset = current_piece.getOffset();
       
        while ((previousFilesLength + current_piece.getLength()) < offset) {
         
          previousFilesLength += current_piece.getLength();
         
          currentFile++;
         
          fileOffset = 0;
         
          current_piece = pieceList.get(currentFile);
        }
   
        List  chunks = new ArrayList();
       
          // Now current_piece points to the first file that contains data for this block
       
        while ( buffer_position < buffer_limit ){
           
          current_piece = pieceList.get(currentFile);
 
          long file_limit = buffer_position +
                    ((current_piece.getFile().getLength() - current_piece.getOffset()) -
                      (offset - previousFilesLength));
          
View Full Code Here

      }
 
      int  pieceNumber  = request.getPieceNumber();
      int  offset    = request.getOffset();
     
      DMPieceList pieceList = disk_manager.getPieceList(pieceNumber);
 
        // temporary fix for bug 784306
     
      if ( pieceList.size() == 0 ){
       
        Debug.out("no pieceList entries for " + pieceNumber);
       
        listener.readCompleted( request, buffer );
       
        return;
      }
 
      long previousFilesLength = 0;
     
      int currentFile = 0;
     
      long fileOffset = pieceList.get(0).getOffset();
     
      while (currentFile < pieceList.size() && pieceList.getCumulativeLengthToPiece(currentFile) < offset) {
       
        previousFilesLength = pieceList.getCumulativeLengthToPiece(currentFile);
       
        currentFile++;
       
        fileOffset = 0;
      }
 
        // update the offset (we're in the middle of a file)
     
      fileOffset += offset - previousFilesLength;
     
      List  chunks = new ArrayList();
     
      int  buffer_position = 0;
           
      while ( buffer_position < length && currentFile < pieceList.size()) {
      
        DMPieceMapEntry map_entry = pieceList.get( currentFile );
             
        int  length_available = map_entry.getLength() - (int)( fileOffset - map_entry.getOffset());
       
          //explicitly limit the read size to the proper length, rather than relying on the underlying file being correctly-sized
          //see long DMWriterAndCheckerImpl::checkPiece note
View Full Code Here

    }
   
    public boolean
    isSkipped()
    {
    final DMPieceList pieceList =diskManager.getPieceList(pieceNumber);
    for (int i =0; i <pieceList.size(); i++){
      if ( !pieceList.get(i).getFile().isSkipped()){
        return( false );
      }
    }
    return( true );
    }
View Full Code Here

  }

  public boolean calcNeeded()
  {
    boolean filesNeeded =false;
    final DMPieceList pieceList =diskManager.getPieceList(pieceNumber);
    for (int i =0; i <pieceList.size(); i++)
    {
      final DiskManagerFileInfoImpl file =pieceList.get(i).getFile();
      final long fileLength =file.getLength();
      filesNeeded |=fileLength >0 &&file.getDownloaded() <fileLength &&!file.isSkipped();
    }
    if (filesNeeded)
    {
View Full Code Here

        if (dmPiece.isDone())
          continue// nothing to do for pieces not needing requesting

        int startPriority =Integer.MIN_VALUE;

        final DMPieceList pieceList =pieceMap.getPieceList(dmPiece.getPieceNumber());
        final int pieceListSize =pieceList.size();
        for (int j =0; j <pieceListSize; j++)
        {
          final DiskManagerFileInfoImpl fileInfo =pieceList.get(j).getFile();
          final long downloaded =fileInfo.getDownloaded();
          final long length =fileInfo.getLength();
          if (length >0 &&downloaded <length &&!fileInfo.isSkipped())
          {
            int priority =0;
View Full Code Here

TOP

Related Classes of org.gudy.azureus2.core3.disk.impl.piecemapper.DMPieceList

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.