internal virtual VolumeScanner.Statistics GetVolumeStats(string volumeId)
{
lock (this)
{
VolumeScanner scanner = scanners[volumeId];
if (scanner == null)
{
return(null);
}
return(scanner.GetStatistics());
}
}
/// <exception cref="System.Exception"/>
public virtual void TestCalculateNeededBytesPerSec()
{
// If we didn't check anything the last hour, we should scan now.
NUnit.Framework.Assert.IsTrue(VolumeScanner.CalculateShouldScan("test", 100, 0, 0
, 60));
// If, on average, we checked 101 bytes/s checked during the last hour,
// stop checking now.
NUnit.Framework.Assert.IsFalse(VolumeScanner.CalculateShouldScan("test", 100, 101
* 3600, 1000, 5000));
// Target is 1 byte / s, but we didn't scan anything in the last minute.
// Should scan now.
NUnit.Framework.Assert.IsTrue(VolumeScanner.CalculateShouldScan("test", 1, 3540,
0, 60));
// Target is 1000000 byte / s, but we didn't scan anything in the last
// minute. Should scan now.
NUnit.Framework.Assert.IsTrue(VolumeScanner.CalculateShouldScan("test", 100000L,
354000000L, 0, 60));
NUnit.Framework.Assert.IsFalse(VolumeScanner.CalculateShouldScan("test", 100000L,
365000000L, 0, 60));
}
public override void Setup(VolumeScanner scanner)
{
this.scanner = scanner;
TestBlockScanner.TestScanResultHandler.Info info = GetInfo(scanner.volume);
Log.Info("about to start scanning.");
lock (info)
{
while (!info.shouldRun)
{
try
{
Sharpen.Runtime.Wait(info);
}
catch (Exception)
{
}
}
}
Log.Info("starting scanning.");
}
/// <summary>Set up a scanner for the given block pool and volume.</summary>
/// <param name="ref">A reference to the volume.</param>
public virtual void AddVolumeScanner(FsVolumeReference @ref)
{
lock (this)
{
bool success = false;
try
{
FsVolumeSpi volume = @ref.GetVolume();
if (!IsEnabled())
{
Log.Debug("Not adding volume scanner for {}, because the block " + "scanner is disabled."
, volume.GetBasePath());
return;
}
VolumeScanner scanner = scanners[volume.GetStorageID()];
if (scanner != null)
{
Log.Error("Already have a scanner for volume {}.", volume.GetBasePath());
return;
}
Log.Debug("Adding scanner for volume {} (StorageID {})", volume.GetBasePath(), volume
.GetStorageID());
scanner = new VolumeScanner(conf, datanode, @ref);
scanner.Start();
scanners[volume.GetStorageID()] = scanner;
success = true;
}
finally
{
if (!success)
{
// If we didn't create a new VolumeScanner object, we don't
// need this reference to the volume.
IOUtils.Cleanup(null, @ref);
}
}
}
}
/// <summary>
/// Stops and removes a volume scanner.<p/>
/// This function will block until the volume scanner has stopped.
/// </summary>
/// <param name="volume">The volume to remove.</param>
public virtual void RemoveVolumeScanner(FsVolumeSpi volume)
{
lock (this)
{
if (!IsEnabled())
{
Log.Debug("Not removing volume scanner for {}, because the block " + "scanner is disabled."
, volume.GetStorageID());
return;
}
VolumeScanner scanner = scanners[volume.GetStorageID()];
if (scanner == null)
{
Log.Warn("No scanner found to remove for volumeId {}", volume.GetStorageID());
return;
}
Log.Info("Removing scanner for volume {} (StorageID {})", volume.GetBasePath(), volume
.GetStorageID());
scanner.Shutdown();
Sharpen.Collections.Remove(scanners, volume.GetStorageID());
Uninterruptibles.JoinUninterruptibly(scanner, 5, TimeUnit.Minutes);
}
}
/// <summary>
/// Mark a block as "suspect."
/// This means that we should try to rescan it soon.
/// </summary>
/// <remarks>
/// Mark a block as "suspect."
/// This means that we should try to rescan it soon. Note that the
/// VolumeScanner keeps a list of recently suspicious blocks, which
/// it uses to avoid rescanning the same block over and over in a short
/// time frame.
/// </remarks>
/// <param name="storageId">
/// The ID of the storage where the block replica
/// is being stored.
/// </param>
/// <param name="block">The block's ID and block pool id.</param>
internal virtual void MarkSuspectBlock(string storageId, ExtendedBlock block)
{
lock (this)
{
if (!IsEnabled())
{
Log.Debug("Not scanning suspicious block {} on {}, because the block " + "scanner is disabled."
, block, storageId);
return;
}
VolumeScanner scanner = scanners[storageId];
if (scanner == null)
{
// This could happen if the volume is in the process of being removed.
// The removal process shuts down the VolumeScanner, but the volume
// object stays around as long as there are references to it (which
// should not be that long.)
Log.Info("Not scanning suspicious block {} on {}, because there is no " + "volume scanner for that storageId."
, block, storageId);
return;
}
scanner.MarkSuspectBlock(block);
}
}
public virtual void Setup(VolumeScanner scanner)
{
Log.Trace("Starting VolumeScanner {}", scanner.volume.GetBasePath());
this.scanner = scanner;
}
