public virtual void TestFuzz()
{
Replica[] replicas = new Replica[100000];
Random rand = new Random(0);
for (int i = 0; i < replicas.Length; i++)
{
Block b = new Block(rand.NextLong(), i, i << 4);
switch (rand.Next(2))
{
case 0:
{
replicas[i] = new FinalizedReplica(b, null, null);
break;
}
case 1:
{
replicas[i] = new ReplicaBeingWritten(b, null, null, null);
break;
}
case 2:
{
replicas[i] = new ReplicaWaitingToBeRecovered(b, null, null);
break;
}
}
}
CheckReport(replicas);
}
/// <summary>Add replicas under the given directory to the volume map</summary>
/// <param name="volumeMap">the replicas map</param>
/// <param name="dir">an input directory</param>
/// <param name="lazyWriteReplicaMap">
/// Map of replicas on transient
/// storage.
/// </param>
/// <param name="isFinalized">
/// true if the directory has finalized replicas;
/// false if the directory has rbw replicas
/// </param>
/// <exception cref="System.IO.IOException"/>
internal virtual void AddToReplicasMap(ReplicaMap volumeMap, FilePath dir, RamDiskReplicaTracker
lazyWriteReplicaMap, bool isFinalized)
{
FilePath[] files = FileUtil.ListFiles(dir);
foreach (FilePath file in files)
{
if (file.IsDirectory())
{
AddToReplicasMap(volumeMap, file, lazyWriteReplicaMap, isFinalized);
}
if (isFinalized && FsDatasetUtil.IsUnlinkTmpFile(file))
{
file = RecoverTempUnlinkedBlock(file);
if (file == null)
{
// the original block still exists, so we cover it
// in another iteration and can continue here
continue;
}
}
if (!Block.IsBlockFilename(file))
{
continue;
}
long genStamp = FsDatasetUtil.GetGenerationStampFromFile(files, file);
long blockId = Block.Filename2id(file.GetName());
ReplicaInfo newReplica = null;
if (isFinalized)
{
newReplica = new FinalizedReplica(blockId, file.Length(), genStamp, volume, file.
GetParentFile());
}
else
{
bool loadRwr = true;
FilePath restartMeta = new FilePath(file.GetParent() + FilePath.pathSeparator + "."
+ file.GetName() + ".restart");
Scanner sc = null;
try
{
sc = new Scanner(restartMeta, "UTF-8");
// The restart meta file exists
if (sc.HasNextLong() && (sc.NextLong() > Time.Now()))
{
// It didn't expire. Load the replica as a RBW.
// We don't know the expected block length, so just use 0
// and don't reserve any more space for writes.
newReplica = new ReplicaBeingWritten(blockId, ValidateIntegrityAndSetLength(file,
genStamp), genStamp, volume, file.GetParentFile(), null, 0);
loadRwr = false;
}
sc.Close();
if (!restartMeta.Delete())
{
FsDatasetImpl.Log.Warn("Failed to delete restart meta file: " + restartMeta.GetPath
());
}
}
catch (FileNotFoundException)
{
}
finally
{
// nothing to do hereFile dir =
if (sc != null)
{
sc.Close();
}
}
// Restart meta doesn't exist or expired.
if (loadRwr)
{
newReplica = new ReplicaWaitingToBeRecovered(blockId, ValidateIntegrityAndSetLength
(file, genStamp), genStamp, volume, file.GetParentFile());
}
}
ReplicaInfo oldReplica = volumeMap.Get(bpid, newReplica.GetBlockId());
if (oldReplica == null)
{
volumeMap.Add(bpid, newReplica);
}
else
{
// We have multiple replicas of the same block so decide which one
// to keep.
newReplica = ResolveDuplicateReplicas(newReplica, oldReplica, volumeMap);
}
// If we are retaining a replica on transient storage make sure
// it is in the lazyWriteReplicaMap so it can be persisted
// eventually.
if (newReplica.GetVolume().IsTransientStorage())
{
lazyWriteReplicaMap.AddReplica(bpid, blockId, (FsVolumeImpl)newReplica.GetVolume(
));
}
else
{
lazyWriteReplicaMap.DiscardReplica(bpid, blockId, false);
}
}
}
