Examples of DMPieceMapEntry


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

               
                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{
             
              listener.checkCompleted( request, passed );
View Full Code Here

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

       
        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
                                 
                                  if ( file_info.getLength() > 0 || !file_info.isSkipped()){
View Full Code Here

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

             
              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;
              }
             
              long  expected_size   = entry.getOffset() + entry.getLength();
              if ( file_size.longValue() < expected_size ){
                pieceCannotExist = true;
                break;
              }
            }
View Full Code Here

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

       
        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));
          
          if ( file_limit > buffer_limit ){
           
            file_limit  = buffer_limit;
          }
           
            // could be a zero-length file
         
          if ( file_limit > buffer_position ){
 
            long  file_pos = fileOffset + (offset - previousFilesLength);
           
            chunks.add(
                new Object[]{ current_piece.getFile(),
                new Long( file_pos ),
                new Integer((int)file_limit )});
                     
            buffer_position = (int)file_limit;
          }
View Full Code Here

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

     
      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
       
        int entry_read_limit = buffer_position + length_available;
       
          // now bring down to the required read length if this is shorter than this
          // chunk of data
       
        entry_read_limit = Math.min( length, entry_read_limit );
       
          // this chunk denotes a read up to buffer offset "entry_read_limit"
       
        chunks.add( new Object[]{ map_entry.getFile().getCacheFile(), new Long(fileOffset), new Integer( entry_read_limit )});
       
        buffer_position = entry_read_limit;
       
        currentFile++;
       
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. 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.