/// <summary>Create application log directories on all disks.</summary>
/// <exception cref="System.IO.IOException"/>
internal virtual void CreateAppLogDirs(string appId, IList <string> logDirs, string
user)
{
bool appLogDirStatus = false;
FsPermission appLogDirPerms = new FsPermission(LogdirPerm);
foreach (string rootLogDir in logDirs)
{
// create $log.dir/$appid
Path appLogDir = new Path(rootLogDir, appId);
try
{
CreateDir(appLogDir, appLogDirPerms, true, user);
}
catch (IOException e)
{
Log.Warn("Unable to create the app-log directory : " + appLogDir, e);
continue;
}
appLogDirStatus = true;
}
if (!appLogDirStatus)
{
throw new IOException("Not able to initialize app-log directories " + "in any of the configured local directories for app "
+ appId);
}
}
// copy user specified log4j.property file in local
// to HDFS with putting on distributed cache and adding its parent directory
// to classpath.
/// <exception cref="System.IO.IOException"/>
private void CopyLog4jPropertyFile(Job job, Path submitJobDir, short replication)
{
Configuration conf = job.GetConfiguration();
string file = ValidateFilePath(conf.Get(MRJobConfig.MapreduceJobLog4jPropertiesFile
), conf);
Log.Debug("default FileSystem: " + jtFs.GetUri());
FsPermission mapredSysPerms = new FsPermission(JobSubmissionFiles.JobDirPermission
);
if (!jtFs.Exists(submitJobDir))
{
throw new IOException("Cannot find job submission directory! " + "It should just be created, so something wrong here."
);
}
Path fileDir = JobSubmissionFiles.GetJobLog4jFile(submitJobDir);
// first copy local log4j.properties file to HDFS under submitJobDir
if (file != null)
{
FileSystem.Mkdirs(jtFs, fileDir, mapredSysPerms);
URI tmpURI = null;
try
{
tmpURI = new URI(file);
}
catch (URISyntaxException e)
{
throw new ArgumentException(e);
}
Path tmp = new Path(tmpURI);
Path newPath = CopyRemoteFiles(fileDir, tmp, conf, replication);
DistributedCache.AddFileToClassPath(new Path(newPath.ToUri().GetPath()), conf);
}
}
/// <summary>Initialize the local directories for a particular user.</summary>
/// <remarks>
/// Initialize the local directories for a particular user.
/// <ul>.mkdir
/// <li>$local.dir/usercache/$user</li>
/// </ul>
/// </remarks>
/// <exception cref="System.IO.IOException"/>
internal virtual void CreateUserLocalDirs(IList <string> localDirs, string user)
{
bool userDirStatus = false;
FsPermission userperms = new FsPermission(UserPerm);
foreach (string localDir in localDirs)
{
// create $local.dir/usercache/$user and its immediate parent
try
{
CreateDir(GetUserCacheDir(new Path(localDir), user), userperms, true, user);
}
catch (IOException e)
{
Log.Warn("Unable to create the user directory : " + localDir, e);
continue;
}
userDirStatus = true;
}
if (!userDirStatus)
{
throw new IOException("Not able to initialize user directories " + "in any of the configured local directories for user "
+ user);
}
}
/// <summary>Initialize the local directories for a particular user.</summary>
/// <remarks>
/// Initialize the local directories for a particular user.
/// <ul>
/// <li>$local.dir/usercache/$user/appcache/$appid</li>
/// </ul>
/// </remarks>
/// <param name="localDirs"/>
/// <exception cref="System.IO.IOException"/>
internal virtual void CreateAppDirs(IList <string> localDirs, string user, string
appId)
{
bool initAppDirStatus = false;
FsPermission appperms = new FsPermission(AppdirPerm);
foreach (string localDir in localDirs)
{
Path fullAppDir = GetApplicationDir(new Path(localDir), user, appId);
// create $local.dir/usercache/$user/appcache/$appId
try
{
CreateDir(fullAppDir, appperms, true, user);
initAppDirStatus = true;
}
catch (IOException e)
{
Log.Warn("Unable to create app directory " + fullAppDir.ToString(), e);
}
}
if (!initAppDirStatus)
{
throw new IOException("Not able to initialize app directories " + "in any of the configured local directories for app "
+ appId.ToString());
}
}
public virtual void TestSetPermission()
{
if (Path.Windows)
{
System.Console.Out.WriteLine("Cannot run test for Windows");
return;
}
string filename = "foo";
Path f = fileContextTestHelper.GetTestRootPath(fc, filename);
FileContextTestHelper.CreateFile(fc, f);
try
{
// create files and manipulate them.
FsPermission all = new FsPermission((short)0x1ff);
FsPermission none = new FsPermission((short)0);
fc.SetPermission(f, none);
DoFilePermissionCheck(none, fc.GetFileStatus(f).GetPermission());
fc.SetPermission(f, all);
DoFilePermissionCheck(all, fc.GetFileStatus(f).GetPermission());
}
finally
{
CleanupFile(fc, f);
}
}
/// <exception cref="System.IO.IOException"/>
protected override bool MkOneDirWithMode(Path path, FilePath p2f, FsPermission permission
)
{
if (Log.IsDebugEnabled())
{
Log.Debug(string.Format("EFS:mkOneDirWithMode: %s %s", path, permission));
}
bool ret = false;
// File.mkdir returns false, does not throw. Must mimic it.
try
{
WindowsSecureContainerExecutor.Native.Elevated.Mkdir(path);
SetPermission(path, permission);
ret = true;
}
catch (Exception e)
{
if (Log.IsDebugEnabled())
{
Log.Debug(string.Format("EFS:mkOneDirWithMode: %s", StringUtils.StringifyException
(e)));
}
}
return(ret);
}
/// <exception cref="System.Exception"/>
public virtual void TestFavoredNodesEndToEndForAppend()
{
// create 10 files with random preferred nodes
for (int i = 0; i < NumFiles; i++)
{
Random rand = new Random(Runtime.CurrentTimeMillis() + i);
// pass a new created rand so as to get a uniform distribution each time
// without too much collisions (look at the do-while loop in getDatanodes)
IPEndPoint[] datanode = GetDatanodes(rand);
Path p = new Path("/filename" + i);
// create and close the file.
dfs.Create(p, FsPermission.GetDefault(), true, 4096, (short)3, 4096L, null, null)
.Close();
// re-open for append
FSDataOutputStream @out = dfs.Append(p, EnumSet.Of(CreateFlag.Append), 4096, null
, datanode);
@out.Write(SomeBytes);
@out.Close();
BlockLocation[] locations = GetBlockLocations(p);
// verify the files got created in the right nodes
foreach (BlockLocation loc in locations)
{
string[] hosts = loc.GetNames();
string[] hosts1 = GetStringForInetSocketAddrs(datanode);
NUnit.Framework.Assert.IsTrue(CompareNodes(hosts, hosts1));
}
}
}
/// <exception cref="System.Exception"/>
private void _mkdirs(bool exists, FsPermission before, FsPermission after)
{
FilePath localDir = MockitoMaker.Make(MockitoMaker.Stub <FilePath>().Returning(exists
).from.Exists());
Org.Mockito.Mockito.When(localDir.Mkdir()).ThenReturn(true);
Path dir = Org.Mockito.Mockito.Mock <Path>();
// use default stubs
LocalFileSystem fs = MockitoMaker.Make(MockitoMaker.Stub <LocalFileSystem>().Returning
(localDir).from.PathToFile(dir));
FileStatus stat = MockitoMaker.Make(MockitoMaker.Stub <FileStatus>().Returning(after
).from.GetPermission());
Org.Mockito.Mockito.When(fs.GetFileStatus(dir)).ThenReturn(stat);
try
{
DiskChecker.MkdirsWithExistsAndPermissionCheck(fs, dir, before);
if (!exists)
{
Org.Mockito.Mockito.Verify(fs).SetPermission(dir, before);
}
else
{
Org.Mockito.Mockito.Verify(fs).GetFileStatus(dir);
Org.Mockito.Mockito.Verify(stat).GetPermission();
}
}
catch (DiskChecker.DiskErrorException e)
{
if (before != after)
{
Assert.True(e.Message.StartsWith("Incorrect permission"));
}
}
}
/// <summary>
/// Creates the new FsPermission for an inode that is receiving an extended
/// ACL, based on its access ACL entries.
/// </summary>
/// <remarks>
/// Creates the new FsPermission for an inode that is receiving an extended
/// ACL, based on its access ACL entries. For a correctly sorted ACL, the
/// first entry is the owner and the last 2 entries are the mask and other
/// entries respectively. Also preserve sticky bit and toggle ACL bit on.
/// Note that this method intentionally copies the permissions of the mask
/// entry into the FsPermission group permissions. This is consistent with the
/// POSIX ACLs model, which presents the mask as the permissions of the group
/// class.
/// </remarks>
/// <param name="accessEntries">List<AclEntry> access ACL entries</param>
/// <param name="existingPerm">FsPermission existing permissions</param>
/// <returns>FsPermission new permissions</returns>
private static FsPermission CreateFsPermissionForExtendedAcl(IList <AclEntry> accessEntries
, FsPermission existingPerm)
{
return(new FsPermission(accessEntries[0].GetPermission(), accessEntries[accessEntries
.Count - 2].GetPermission(), accessEntries[accessEntries.Count - 1].GetPermission
(), existingPerm.GetStickyBit()));
}
/// <exception cref="System.IO.IOException"/>
protected internal void MakeTestFile(Path path, long length, bool isLazyPersist)
{
EnumSet <CreateFlag> createFlags = EnumSet.Of(CreateFlag.Create);
if (isLazyPersist)
{
createFlags.AddItem(CreateFlag.LazyPersist);
}
FSDataOutputStream fos = null;
try
{
fos = fs.Create(path, FsPermission.GetFileDefault(), createFlags, BufferLength, ReplFactor
, BlockSize, null);
// Allocate a block.
byte[] buffer = new byte[BufferLength];
for (int bytesWritten = 0; bytesWritten < length;)
{
fos.Write(buffer, 0, buffer.Length);
bytesWritten += buffer.Length;
}
if (length > 0)
{
fos.Hsync();
}
}
finally
{
IOUtils.CloseQuietly(fos);
}
}
/// <exception cref="NoSuchAlgorithmException"/>
/// <exception cref="CertificateException"/>
/// <exception cref="System.IO.IOException"/>
private FsPermission LoadAndReturnPerm(Path pathToLoad, Path pathToDelete)
{
FsPermission perm = null;
try
{
perm = LoadFromPath(pathToLoad, password);
RenameOrFail(pathToLoad, path);
Log.Debug(string.Format("KeyStore loaded successfully from '%s'!!", pathToLoad));
if (fs.Exists(pathToDelete))
{
fs.Delete(pathToDelete, true);
}
}
catch (IOException e)
{
// Check for password issue : don't want to trash file due
// to wrong password
if (IsBadorWrongPassword(e))
{
throw;
}
}
return(perm);
}
/// <summary>
/// The KeyStore might have gone down during a flush, In which case either the
/// _NEW or _OLD files might exists.
/// </summary>
/// <remarks>
/// The KeyStore might have gone down during a flush, In which case either the
/// _NEW or _OLD files might exists. This method tries to load the KeyStore
/// from one of these intermediate files.
/// </remarks>
/// <param name="oldPath">the _OLD file created during flush</param>
/// <param name="newPath">the _NEW file created during flush</param>
/// <returns>The permissions of the loaded file</returns>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="NoSuchAlgorithmException"/>
/// <exception cref="CertificateException"/>
private FsPermission TryLoadIncompleteFlush(Path oldPath, Path newPath)
{
FsPermission perm = null;
// Check if _NEW exists (in case flush had finished writing but not
// completed the re-naming)
if (fs.Exists(newPath))
{
perm = LoadAndReturnPerm(newPath, oldPath);
}
// try loading from _OLD (An earlier Flushing MIGHT not have completed
// writing completely)
if ((perm == null) && fs.Exists(oldPath))
{
perm = LoadAndReturnPerm(oldPath, newPath);
}
// If not loaded yet,
// required to create an empty keystore. *sigh*
if (perm == null)
{
keyStore.Load(null, password);
Log.Debug("KeyStore initialized anew successfully !!");
perm = new FsPermission("700");
}
return(perm);
}
/// <summary>
/// Try loading from the user specified path, else load from the backup
/// path in case Exception is not due to bad/wrong password
/// </summary>
/// <param name="path">Actual path to load from</param>
/// <param name="backupPath">Backup path (_OLD)</param>
/// <returns>The permissions of the loaded file</returns>
/// <exception cref="NoSuchAlgorithmException"/>
/// <exception cref="CertificateException"/>
/// <exception cref="System.IO.IOException"/>
private FsPermission TryLoadFromPath(Path path, Path backupPath)
{
FsPermission perm = null;
try
{
perm = LoadFromPath(path, password);
// Remove _OLD if exists
if (fs.Exists(backupPath))
{
fs.Delete(backupPath, true);
}
Log.Debug("KeyStore loaded successfully !!");
}
catch (IOException ioe)
{
// If file is corrupted for some reason other than
// wrong password try the _OLD file if exits
if (!IsBadorWrongPassword(ioe))
{
perm = LoadFromPath(backupPath, password);
// Rename CURRENT to CORRUPTED
RenameOrFail(path, new Path(path.ToString() + "_CORRUPTED_" + Runtime.CurrentTimeMillis
()));
RenameOrFail(backupPath, path);
Log.Debug(string.Format("KeyStore loaded successfully from '%s' since '%s'" + "was corrupted !!"
, backupPath, path));
}
else
{
throw;
}
}
return(perm);
}
/// <exception cref="System.Exception"/>
private void TestCreate(Path path, bool @override)
{
FileSystem fs = GetHttpFSFileSystem();
FsPermission permission = new FsPermission(FsAction.ReadWrite, FsAction.None, FsAction
.None);
OutputStream os = fs.Create(new Path(path.ToUri().GetPath()), permission, @override
, 1024, (short)2, 100 * 1024 * 1024, null);
os.Write(1);
os.Close();
fs.Close();
fs = FileSystem.Get(GetProxiedFSConf());
FileStatus status = fs.GetFileStatus(path);
if (!IsLocalFS())
{
NUnit.Framework.Assert.AreEqual(status.GetReplication(), 2);
NUnit.Framework.Assert.AreEqual(status.GetBlockSize(), 100 * 1024 * 1024);
}
NUnit.Framework.Assert.AreEqual(status.GetPermission(), permission);
InputStream @is = fs.Open(path);
NUnit.Framework.Assert.AreEqual(@is.Read(), 1);
@is.Close();
fs.Close();
}
/// <exception cref="System.Exception"/>
protected internal virtual void TestSetPermission()
{
FileSystem fs = FileSystem.Get(GetProxiedFSConf());
Path path = new Path(GetProxiedFSTestDir(), "foodir");
fs.Mkdirs(path);
fs = GetHttpFSFileSystem();
FsPermission permission1 = new FsPermission(FsAction.ReadWrite, FsAction.None, FsAction
.None);
fs.SetPermission(path, permission1);
fs.Close();
fs = FileSystem.Get(GetProxiedFSConf());
FileStatus status1 = fs.GetFileStatus(path);
fs.Close();
FsPermission permission2 = status1.GetPermission();
NUnit.Framework.Assert.AreEqual(permission2, permission1);
//sticky bit
fs = GetHttpFSFileSystem();
permission1 = new FsPermission(FsAction.ReadWrite, FsAction.None, FsAction.None,
true);
fs.SetPermission(path, permission1);
fs.Close();
fs = FileSystem.Get(GetProxiedFSConf());
status1 = fs.GetFileStatus(path);
fs.Close();
permission2 = status1.GetPermission();
NUnit.Framework.Assert.IsTrue(permission2.GetStickyBit());
NUnit.Framework.Assert.AreEqual(permission2, permission1);
}
// add a bunch of transactions.
public virtual void Run()
{
thr = Sharpen.Thread.CurrentThread();
FsPermission p = new FsPermission((short)0x1ff);
int i = 0;
while (!stopped)
{
try
{
string dirname = "/thr-" + thr.GetId() + "-dir-" + i;
nn.Mkdirs(dirname, p, true);
nn.Delete(dirname, true);
}
catch (SafeModeException)
{
}
catch (Exception e)
{
// This is OK - the tests will bring NN in and out of safemode
Log.Warn("Got error in transaction thread", e);
caught.CompareAndSet(null, e);
break;
}
i++;
}
}
/// <summary>
/// Set the
/// <see cref="Org.Apache.Hadoop.FS.Permission.FsPermission"/>
/// of this
/// <see cref="INode"/>
///
/// </summary>
internal virtual Org.Apache.Hadoop.Hdfs.Server.Namenode.INode SetPermission(FsPermission
permission, int latestSnapshotId)
{
RecordModification(latestSnapshotId);
SetPermission(permission);
return(this);
}
/// <exception cref="System.IO.IOException"/>
private static void UnprotectedRemoveAcl(FSDirectory fsd, INodesInPath iip)
{
System.Diagnostics.Debug.Assert(fsd.HasWriteLock());
INode inode = FSDirectory.ResolveLastINode(iip);
int snapshotId = iip.GetLatestSnapshotId();
AclFeature f = inode.GetAclFeature();
if (f == null)
{
return;
}
FsPermission perm = inode.GetFsPermission();
IList <AclEntry> featureEntries = AclStorage.GetEntriesFromAclFeature(f);
if (featureEntries[0].GetScope() == AclEntryScope.Access)
{
// Restore group permissions from the feature's entry to permission
// bits, overwriting the mask, which is not part of a minimal ACL.
AclEntry groupEntryKey = new AclEntry.Builder().SetScope(AclEntryScope.Access).SetType
(AclEntryType.Group).Build();
int groupEntryIndex = Sharpen.Collections.BinarySearch(featureEntries, groupEntryKey
, AclTransformation.AclEntryComparator);
System.Diagnostics.Debug.Assert(groupEntryIndex >= 0);
FsAction groupPerm = featureEntries[groupEntryIndex].GetPermission();
FsPermission newPerm = new FsPermission(perm.GetUserAction(), groupPerm, perm.GetOtherAction
(), perm.GetStickyBit());
inode.SetPermission(newPerm, snapshotId);
}
inode.RemoveAclFeature(snapshotId);
}
/// <summary>Tests modifying xattrs on a directory that has been snapshotted</summary>
/// <exception cref="System.Exception"/>
public virtual void TestModifyReadsCurrentState()
{
// Init
FileSystem.Mkdirs(hdfs, path, FsPermission.CreateImmutable((short)0x1c0));
SnapshotTestHelper.CreateSnapshot(hdfs, path, snapshotName);
hdfs.SetXAttr(path, name1, value1);
hdfs.SetXAttr(path, name2, value2);
// Verify that current path reflects xattrs, snapshot doesn't
IDictionary <string, byte[]> xattrs = hdfs.GetXAttrs(path);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 2);
Assert.AssertArrayEquals(value1, xattrs[name1]);
Assert.AssertArrayEquals(value2, xattrs[name2]);
xattrs = hdfs.GetXAttrs(snapshotPath);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 0);
// Modify each xattr and make sure it's reflected
hdfs.SetXAttr(path, name1, value2, EnumSet.Of(XAttrSetFlag.Replace));
xattrs = hdfs.GetXAttrs(path);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 2);
Assert.AssertArrayEquals(value2, xattrs[name1]);
Assert.AssertArrayEquals(value2, xattrs[name2]);
hdfs.SetXAttr(path, name2, value1, EnumSet.Of(XAttrSetFlag.Replace));
xattrs = hdfs.GetXAttrs(path);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 2);
Assert.AssertArrayEquals(value2, xattrs[name1]);
Assert.AssertArrayEquals(value1, xattrs[name2]);
// Paranoia checks
xattrs = hdfs.GetXAttrs(snapshotPath);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 0);
hdfs.RemoveXAttr(path, name1);
hdfs.RemoveXAttr(path, name2);
xattrs = hdfs.GetXAttrs(path);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 0);
}
internal override void SetPermission(FsPermission permission)
{
short mode = permission.ToShort();
UpdatePermissionStatus(INodeWithAdditionalFields.PermissionStatusFormat.Mode, mode
);
}
public virtual void TestXAttrForSnapshotRootAfterRemove()
{
FileSystem.Mkdirs(hdfs, path, FsPermission.CreateImmutable((short)0x1c0));
hdfs.SetXAttr(path, name1, value1);
hdfs.SetXAttr(path, name2, value2);
SnapshotTestHelper.CreateSnapshot(hdfs, path, snapshotName);
// Both original and snapshot have same XAttrs.
IDictionary <string, byte[]> xattrs = hdfs.GetXAttrs(path);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 2);
Assert.AssertArrayEquals(value1, xattrs[name1]);
Assert.AssertArrayEquals(value2, xattrs[name2]);
xattrs = hdfs.GetXAttrs(snapshotPath);
NUnit.Framework.Assert.AreEqual(xattrs.Count, 2);
Assert.AssertArrayEquals(value1, xattrs[name1]);
Assert.AssertArrayEquals(value2, xattrs[name2]);
// Original XAttrs have been removed, but snapshot still has old XAttrs.
hdfs.RemoveXAttr(path, name1);
hdfs.RemoveXAttr(path, name2);
DoSnapshotRootRemovalAssertions(path, snapshotPath);
Restart(false);
DoSnapshotRootRemovalAssertions(path, snapshotPath);
Restart(true);
DoSnapshotRootRemovalAssertions(path, snapshotPath);
}
public virtual void TestSetXAttrSnapshotPath()
{
FileSystem.Mkdirs(hdfs, path, FsPermission.CreateImmutable((short)0x1c0));
SnapshotTestHelper.CreateSnapshot(hdfs, path, snapshotName);
exception.Expect(typeof(SnapshotAccessControlException));
hdfs.SetXAttr(snapshotPath, name1, value1);
}
public override FSDataOutputStream CreateNonRecursive(Path f, FsPermission permission
, EnumSet <CreateFlag> flags, int bufferSize, short replication, long blockSize,
Progressable progress)
{
return(fs.CreateNonRecursive(f, permission, flags, bufferSize, replication, blockSize
, progress));
}
/// <exception cref="System.IO.IOException"/>
protected internal override FSDataOutputStream PrimitiveCreate(Path f, FsPermission
absolutePermission, EnumSet <CreateFlag> flag, int bufferSize, short replication
, long blockSize, Progressable progress, Options.ChecksumOpt checksumOpt)
{
return(fs.PrimitiveCreate(f, absolutePermission, flag, bufferSize, replication, blockSize
, progress, checksumOpt));
}
public virtual void TestCreateDirectories()
{
conf.Set(CommonConfigurationKeys.FsPermissionsUmaskKey, "077");
string dirA = new FilePath(testDir, "dirA").GetPath();
string dirB = new FilePath(dirA, "dirB").GetPath();
string dirC = new FilePath(testDir, "dirC").GetPath();
Path pathC = new Path(dirC);
FsPermission permDirC = new FsPermission((short)0x1c8);
localFs.Mkdir(pathC, null, true);
localFs.SetPermission(pathC, permDirC);
string[] dirs = new string[] { dirA, dirB, dirC };
DirectoryCollection dc = new DirectoryCollection(dirs, conf.GetFloat(YarnConfiguration
.NmMaxPerDiskUtilizationPercentage, YarnConfiguration.DefaultNmMaxPerDiskUtilizationPercentage
));
FsPermission defaultPerm = FsPermission.GetDefault().ApplyUMask(new FsPermission(
(short)FsPermission.DefaultUmask));
bool createResult = dc.CreateNonExistentDirs(localFs, defaultPerm);
NUnit.Framework.Assert.IsTrue(createResult);
FileStatus status = localFs.GetFileStatus(new Path(dirA));
NUnit.Framework.Assert.AreEqual("local dir parent not created with proper permissions"
, defaultPerm, status.GetPermission());
status = localFs.GetFileStatus(new Path(dirB));
NUnit.Framework.Assert.AreEqual("local dir not created with proper permissions",
defaultPerm, status.GetPermission());
status = localFs.GetFileStatus(pathC);
NUnit.Framework.Assert.AreEqual("existing local directory permissions modified",
permDirC, status.GetPermission());
}
/// <exception cref="System.IO.IOException"/>
public override FSDataOutputStream Create(Path f, FsPermission permission, EnumSet
<CreateFlag> flags, int bufferSize, short replication, long blockSize, Progressable
progress, Options.ChecksumOpt checksumOpt)
{
return(fs.Create(f, permission, flags, bufferSize, replication, blockSize, progress
, checksumOpt));
}
public virtual void TestBackwardCompatibility()
{
// Test 1 - old configuration key with decimal
// umask value should be handled when set using
// FSPermission.setUMask() API
FsPermission perm = new FsPermission((short)18);
Configuration conf = new Configuration();
FsPermission.SetUMask(conf, perm);
NUnit.Framework.Assert.AreEqual(18, FsPermission.GetUMask(conf).ToShort());
// Test 2 - old configuration key set with decimal
// umask value should be handled
perm = new FsPermission((short)18);
conf = new Configuration();
conf.Set(FsPermission.DeprecatedUmaskLabel, "18");
NUnit.Framework.Assert.AreEqual(18, FsPermission.GetUMask(conf).ToShort());
// Test 3 - old configuration key overrides the new one
conf = new Configuration();
conf.Set(FsPermission.DeprecatedUmaskLabel, "18");
conf.Set(FsPermission.UmaskLabel, "000");
NUnit.Framework.Assert.AreEqual(18, FsPermission.GetUMask(conf).ToShort());
// Test 4 - new configuration key is handled
conf = new Configuration();
conf.Set(FsPermission.UmaskLabel, "022");
NUnit.Framework.Assert.AreEqual(18, FsPermission.GetUMask(conf).ToShort());
}
public _PrivilegedExceptionAction_419(FSDownload _enclosing, Path path, FsPermission
fPerm)
{
this._enclosing = _enclosing;
this.path = path;
this.fPerm = fPerm;
}
/// <summary>
/// Create any non-existent directories and parent directories, updating the
/// list of valid directories if necessary.
/// </summary>
/// <param name="localFs">local file system to use</param>
/// <param name="perm">absolute permissions to use for any directories created</param>
/// <returns>true if there were no errors, false if at least one error occurred</returns>
internal virtual bool CreateNonExistentDirs(FileContext localFs, FsPermission perm
)
{
lock (this)
{
bool failed = false;
foreach (string dir in localDirs)
{
try
{
CreateDir(localFs, new Path(dir), perm);
}
catch (IOException e)
{
Log.Warn("Unable to create directory " + dir + " error " + e.Message + ", removing from the list of valid directories."
);
localDirs.Remove(dir);
errorDirs.AddItem(dir);
numFailures++;
failed = true;
}
}
return(!failed);
}
}
/// <summary>Create a new cache pool based on a CachePoolInfo object and the defaults.
/// </summary>
/// <remarks>
/// Create a new cache pool based on a CachePoolInfo object and the defaults.
/// We will fill in information that was not supplied according to the
/// defaults.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
internal static CachePool CreateFromInfoAndDefaults(CachePoolInfo info)
{
UserGroupInformation ugi = null;
string ownerName = info.GetOwnerName();
if (ownerName == null)
{
ugi = NameNode.GetRemoteUser();
ownerName = ugi.GetShortUserName();
}
string groupName = info.GetGroupName();
if (groupName == null)
{
if (ugi == null)
{
ugi = NameNode.GetRemoteUser();
}
groupName = ugi.GetPrimaryGroupName();
}
FsPermission mode = (info.GetMode() == null) ? FsPermission.GetCachePoolDefault()
: info.GetMode();
long limit = info.GetLimit() == null ? CachePoolInfo.DefaultLimit : info.GetLimit
();
long maxRelativeExpiry = info.GetMaxRelativeExpiryMs() == null ? CachePoolInfo.DefaultMaxRelativeExpiry
: info.GetMaxRelativeExpiryMs();
return(new CachePool(info.GetPoolName(), ownerName, groupName, mode, limit, maxRelativeExpiry
));
}
public FSDataOutputStream create(Path path, FsPermission fsPermission,
bool overwrite, int bufferSize,
short replication, long blockSize,
Progressable progressable
) {
MockFile file = null;
for(MockFile currentFile: files) {
if (currentFile.path.equals(path)) {
file = currentFile;
break;
}
}
if (file == null) {
file = new MockFile(path.toString(), (int) blockSize, new byte[0]);
files.add(file);
}
return new MockOutputStream(file);
}
public bool mkdirs(Path path, FsPermission fsPermission) {
return false;
}
