/// <summary>Simple acl tests on a directory: set a default acl, remove default acls.
/// </summary>
/// <exception cref="System.Exception"/>
private void TestDirAcls()
{
if (IsLocalFS())
{
return;
}
string defUser1 = "default:user:glarch:r-x";
FileSystem proxyFs = FileSystem.Get(GetProxiedFSConf());
FileSystem httpfs = GetHttpFSFileSystem();
Path dir = GetProxiedFSTestDir();
/* ACL Status on a directory */
AclStatus proxyAclStat = proxyFs.GetAclStatus(dir);
AclStatus httpfsAclStat = httpfs.GetAclStatus(dir);
AssertSameAcls(httpfsAclStat, proxyAclStat);
/* Set a default ACL on the directory */
httpfs.SetAcl(dir, (AclEntry.ParseAclSpec(defUser1, true)));
proxyAclStat = proxyFs.GetAclStatus(dir);
httpfsAclStat = httpfs.GetAclStatus(dir);
AssertSameAcls(httpfsAclStat, proxyAclStat);
/* Remove the default ACL */
httpfs.RemoveDefaultAcl(dir);
proxyAclStat = proxyFs.GetAclStatus(dir);
httpfsAclStat = httpfs.GetAclStatus(dir);
AssertSameAcls(httpfsAclStat, proxyAclStat);
}
public virtual void TestCustomProvider()
{
FileSystem fs = FileSystem.Get(miniDFS.GetConfiguration(0));
fs.Mkdirs(new Path("/user/xxx"));
FileStatus status = fs.GetFileStatus(new Path("/user/xxx"));
NUnit.Framework.Assert.AreEqual(Runtime.GetProperty("user.name"), status.GetOwner
());
NUnit.Framework.Assert.AreEqual("supergroup", status.GetGroup());
NUnit.Framework.Assert.AreEqual(new FsPermission((short)0x1ed), status.GetPermission
());
fs.Mkdirs(new Path("/user/authz"));
Path p = new Path("/user/authz");
status = fs.GetFileStatus(p);
NUnit.Framework.Assert.AreEqual("foo", status.GetOwner());
NUnit.Framework.Assert.AreEqual("bar", status.GetGroup());
NUnit.Framework.Assert.AreEqual(new FsPermission((short)0x1f8), status.GetPermission
());
AclStatus aclStatus = fs.GetAclStatus(p);
NUnit.Framework.Assert.AreEqual(1, aclStatus.GetEntries().Count);
NUnit.Framework.Assert.AreEqual(AclEntryType.Group, aclStatus.GetEntries()[0].GetType
());
NUnit.Framework.Assert.AreEqual("xxx", aclStatus.GetEntries()[0].GetName());
NUnit.Framework.Assert.AreEqual(FsAction.All, aclStatus.GetEntries()[0].GetPermission
());
IDictionary <string, byte[]> xAttrs = fs.GetXAttrs(p);
NUnit.Framework.Assert.IsTrue(xAttrs.Contains("user.test"));
NUnit.Framework.Assert.AreEqual(2, xAttrs["user.test"].Length);
}
public virtual void TestRootACLAfterLoadingFsImage()
{
DistributedFileSystem fs = cluster.GetFileSystem();
Path rootdir = new Path("/");
AclEntry e1 = new AclEntry.Builder().SetName("foo").SetPermission(FsAction.All).SetScope
(AclEntryScope.Access).SetType(AclEntryType.Group).Build();
AclEntry e2 = new AclEntry.Builder().SetName("bar").SetPermission(FsAction.Read).
SetScope(AclEntryScope.Access).SetType(AclEntryType.Group).Build();
fs.ModifyAclEntries(rootdir, Lists.NewArrayList(e1, e2));
AclStatus s = cluster.GetNamesystem().GetAclStatus(rootdir.ToString());
AclEntry[] returned = Sharpen.Collections.ToArray(Lists.NewArrayList(s.GetEntries
()), new AclEntry[0]);
Assert.AssertArrayEquals(new AclEntry[] { AclTestHelpers.AclEntry(AclEntryScope.Access
, AclEntryType.Group, FsAction.ReadExecute), AclTestHelpers.AclEntry(AclEntryScope
.Access, AclEntryType.Group, "bar", FsAction.Read), AclTestHelpers.AclEntry(AclEntryScope
.Access, AclEntryType.Group, "foo", FsAction.All) }, returned);
// restart - hence save and load from fsimage
Restart(fs, true);
s = cluster.GetNamesystem().GetAclStatus(rootdir.ToString());
returned = Sharpen.Collections.ToArray(Lists.NewArrayList(s.GetEntries()), new AclEntry
[0]);
Assert.AssertArrayEquals(new AclEntry[] { AclTestHelpers.AclEntry(AclEntryScope.Access
, AclEntryType.Group, FsAction.ReadExecute), AclTestHelpers.AclEntry(AclEntryScope
.Access, AclEntryType.Group, "bar", FsAction.Read), AclTestHelpers.AclEntry(AclEntryScope
.Access, AclEntryType.Group, "foo", FsAction.All) }, returned);
}
private AclStatus GetFullAcl(AclStatus acl)
{
if (acl.Entries != null && acl.Permission != null && acl.Permission.Length >= 3)
{
var permissionString = acl.Permission;
var permissionLength = permissionString.Length;
var ownerOctal = permissionString.ElementAt(permissionLength - 3).ToString();
var groupOctal = permissionString.ElementAt(permissionLength - 2).ToString();
var otherOctal = permissionString.ElementAt(permissionLength - 1).ToString();
acl.Entries.Add(new AclEntry(AclType.user, string.Empty, AclScope.Access, (AclAction)int.Parse(ownerOctal)));
acl.Entries.Add(new AclEntry(AclType.other, string.Empty, AclScope.Access, (AclAction)int.Parse(otherOctal)));
if (acl.Entries.FirstOrDefault(e => e.Type == AclType.group && string.IsNullOrEmpty(e.UserOrGroupId)) != null)
{
acl.Entries.Add(new AclEntry(AclType.mask, string.Empty, AclScope.Access, (AclAction)int.Parse(groupOctal)));
}
else
{
acl.Entries.Add(new AclEntry(AclType.group, string.Empty, AclScope.Access, (AclAction)int.Parse(groupOctal)));
}
}
return(acl);
}
public virtual void TestInternalGetAclStatus()
{
UserGroupInformation currentUser = UserGroupInformation.GetCurrentUser();
AclStatus aclStatus = fsView.GetAclStatus(new Path("/internalDir"));
Assert.Equal(aclStatus.GetOwner(), currentUser.GetUserName());
Assert.Equal(aclStatus.GetGroup(), currentUser.GetGroupNames()
[0]);
Assert.Equal(aclStatus.GetEntries(), AclUtil.GetMinimalAcl(Constants
.Permission555));
NUnit.Framework.Assert.IsFalse(aclStatus.IsStickyBit());
}
internal static DataLakeStoreItemAce[] GetAclFromStatus(AclStatus aclStatus)
{
var toReturn = new DataLakeStoreItemAce[aclStatus.Entries.Count()];
var index = 0;
foreach (var entry in aclStatus.Entries)
{
toReturn[index++] = Parse(entry);
}
return(toReturn);
}
/// <summary>Return the JSON formatted ACL status of the specified file.</summary>
/// <param name="path">a path specifies a file</param>
/// <returns>JSON formatted AclStatus</returns>
/// <exception cref="System.IO.IOException">if failed to serialize fileStatus to JSON.
/// </exception>
internal virtual string GetAclStatus(string path)
{
PermissionStatus p = GetPermissionStatus(path);
IList <AclEntry> aclEntryList = GetAclEntryList(path);
FsPermission permission = p.GetPermission();
AclStatus.Builder builder = new AclStatus.Builder();
builder.Owner(p.GetUserName()).Group(p.GetGroupName()).AddEntries(aclEntryList).SetPermission
(permission).StickyBit(permission.GetStickyBit());
AclStatus aclStatus = builder.Build();
return(JsonUtil.ToJsonString(aclStatus));
}
/// <summary>
/// Create one StatusPair by performing the underlying calls to
/// fs.getFileStatus and fs.getAclStatus
/// </summary>
/// <param name="fs">The FileSystem where 'path' lives</param>
/// <param name="path">The file/directory to query</param>
/// <exception cref="System.IO.IOException"/>
public StatusPair(FileSystem fs, Path path)
{
fileStatus = fs.GetFileStatus(path);
aclStatus = null;
try
{
aclStatus = fs.GetAclStatus(path);
}
catch (AclException)
{
}
catch (NotSupportedException)
{
}
}
/// <summary>Runs assertions testing that two AclStatus objects contain the same info
/// </summary>
/// <param name="a">First AclStatus</param>
/// <param name="b">Second AclStatus</param>
/// <exception cref="System.Exception"/>
private void AssertSameAcls(AclStatus a, AclStatus b)
{
NUnit.Framework.Assert.IsTrue(a.GetOwner().Equals(b.GetOwner()));
NUnit.Framework.Assert.IsTrue(a.GetGroup().Equals(b.GetGroup()));
NUnit.Framework.Assert.IsTrue(a.IsStickyBit() == b.IsStickyBit());
NUnit.Framework.Assert.IsTrue(a.GetEntries().Count == b.GetEntries().Count);
foreach (AclEntry e in a.GetEntries())
{
NUnit.Framework.Assert.IsTrue(b.GetEntries().Contains(e));
}
foreach (AclEntry e_1 in b.GetEntries())
{
NUnit.Framework.Assert.IsTrue(a.GetEntries().Contains(e_1));
}
}
/// <summary>Convert a AclStatus object to a Json string.</summary>
public static string ToJsonString(AclStatus status)
{
if (status == null)
{
return(null);
}
IDictionary <string, object> m = new SortedDictionary <string, object>();
m["owner"] = status.GetOwner();
m["group"] = status.GetGroup();
m["stickyBit"] = status.IsStickyBit();
IList <string> stringEntries = new AList <string>();
foreach (AclEntry entry in status.GetEntries())
{
stringEntries.AddItem(entry.ToString());
}
m["entries"] = stringEntries;
FsPermission perm = status.GetPermission();
if (perm != null)
{
m["permission"] = ToString(perm);
if (perm.GetAclBit())
{
m["aclBit"] = true;
}
if (perm.GetEncryptedBit())
{
m["encBit"] = true;
}
}
IDictionary <string, IDictionary <string, object> > finalMap = new SortedDictionary <
string, IDictionary <string, object> >();
finalMap[typeof(AclStatus).Name] = m;
ObjectMapper mapper = new ObjectMapper();
try
{
return(mapper.WriteValueAsString(finalMap));
}
catch (IOException)
{
}
return(null);
}
/// <summary>Converts an <code>AclStatus</code> object into a JSON object.</summary>
/// <param name="aclStatus">AclStatus object</param>
/// <returns>The JSON representation of the ACLs for the file</returns>
private static IDictionary <string, object> AclStatusToJSON(AclStatus aclStatus)
{
IDictionary <string, object> json = new LinkedHashMap <string, object>();
IDictionary <string, object> inner = new LinkedHashMap <string, object>();
JSONArray entriesArray = new JSONArray();
inner[HttpFSFileSystem.OwnerJson] = aclStatus.GetOwner();
inner[HttpFSFileSystem.GroupJson] = aclStatus.GetGroup();
inner[HttpFSFileSystem.AclStickyBitJson] = aclStatus.IsStickyBit();
foreach (AclEntry e in aclStatus.GetEntries())
{
entriesArray.AddItem(e.ToString());
}
inner[HttpFSFileSystem.AclEntriesJson] = entriesArray;
json[HttpFSFileSystem.AclStatusJson] = inner;
return(json);
}
public virtual void TestWebImageViewerForAcl()
{
WebImageViewer viewer = new WebImageViewer(NetUtils.CreateSocketAddr("localhost:0"
));
try
{
viewer.InitServer(originalFsimage.GetAbsolutePath());
int port = viewer.GetPort();
// create a WebHdfsFileSystem instance
URI uri = new URI("webhdfs://localhost:" + port.ToString());
Configuration conf = new Configuration();
WebHdfsFileSystem webhdfs = (WebHdfsFileSystem)FileSystem.Get(uri, conf);
// GETACLSTATUS operation to a directory without ACL
AclStatus acl = webhdfs.GetAclStatus(new Path("/dirWithNoAcl"));
NUnit.Framework.Assert.AreEqual(writtenAcls["/dirWithNoAcl"], acl);
// GETACLSTATUS operation to a directory with a default ACL
acl = webhdfs.GetAclStatus(new Path("/dirWithDefaultAcl"));
NUnit.Framework.Assert.AreEqual(writtenAcls["/dirWithDefaultAcl"], acl);
// GETACLSTATUS operation to a file without ACL
acl = webhdfs.GetAclStatus(new Path("/noAcl"));
NUnit.Framework.Assert.AreEqual(writtenAcls["/noAcl"], acl);
// GETACLSTATUS operation to a file with a ACL
acl = webhdfs.GetAclStatus(new Path("/withAcl"));
NUnit.Framework.Assert.AreEqual(writtenAcls["/withAcl"], acl);
// GETACLSTATUS operation to a file with several ACL entries
acl = webhdfs.GetAclStatus(new Path("/withSeveralAcls"));
NUnit.Framework.Assert.AreEqual(writtenAcls["/withSeveralAcls"], acl);
// GETACLSTATUS operation to a invalid path
Uri url = new Uri("http://localhost:" + port + "/webhdfs/v1/invalid/?op=GETACLSTATUS"
);
HttpURLConnection connection = (HttpURLConnection)url.OpenConnection();
connection.SetRequestMethod("GET");
connection.Connect();
NUnit.Framework.Assert.AreEqual(HttpURLConnection.HttpNotFound, connection.GetResponseCode
());
}
finally
{
// shutdown the viewer
viewer.Close();
}
}
/// <summary>Construct a list of StatusPair objects</summary>
/// <param name="fs">The FileSystem where 'path' lives</param>
/// <param name="path">The directory to query</param>
/// <param name="filter">A possible filter for entries in the directory</param>
/// <exception cref="System.IO.IOException"/>
public StatusPairs(FileSystem fs, Path path, PathFilter filter)
{
/* Grab all the file statuses at once in an array */
FileStatus[] fileStatuses = fs.ListStatus(path, filter);
/* We'll have an array of StatusPairs of the same length */
AclStatus aclStatus = null;
statusPairs = new FSOperations.StatusPair[fileStatuses.Length];
/*
* For each FileStatus, attempt to acquire an AclStatus. If the
* getAclStatus throws an exception, we assume that ACLs are turned
* off entirely and abandon the attempt.
*/
bool useAcls = true;
// Assume ACLs work until proven otherwise
for (int i = 0; i < fileStatuses.Length; i++)
{
if (useAcls)
{
try
{
aclStatus = fs.GetAclStatus(fileStatuses[i].GetPath());
}
catch (AclException)
{
/* Almost certainly due to an "ACLs not enabled" exception */
aclStatus = null;
useAcls = false;
}
catch (NotSupportedException)
{
/* Ditto above - this is the case for a local file system */
aclStatus = null;
useAcls = false;
}
}
statusPairs[i] = new FSOperations.StatusPair(fileStatuses[i], aclStatus);
}
}
/// <summary>Prints a single extended ACL entry.</summary>
/// <remarks>
/// Prints a single extended ACL entry. If the mask restricts the
/// permissions of the entry, then also prints the restricted version as the
/// effective permissions. The mask applies to all named entries and also
/// the unnamed group entry.
/// </remarks>
/// <param name="aclStatus">AclStatus for the path</param>
/// <param name="fsPerm">FsPermission for the path</param>
/// <param name="entry">AclEntry extended ACL entry to print</param>
private void PrintExtendedAclEntry(AclStatus aclStatus, FsPermission fsPerm, AclEntry
entry)
{
if (entry.GetName() != null || entry.GetType() == AclEntryType.Group)
{
FsAction entryPerm = entry.GetPermission();
FsAction effectivePerm = aclStatus.GetEffectivePermission(entry, fsPerm);
if (entryPerm != effectivePerm)
{
@out.WriteLine(string.Format("%s\t#effective:%s", entry, effectivePerm.Symbol));
}
else
{
@out.WriteLine(entry);
}
}
else
{
@out.WriteLine(entry);
}
}
/// <exception cref="System.IO.IOException"/>
private void TestAcl(bool persistNamespace)
{
Path p = new Path("/p");
DistributedFileSystem fs = cluster.GetFileSystem();
fs.Create(p).Close();
fs.Mkdirs(new Path("/23"));
AclEntry e = new AclEntry.Builder().SetName("foo").SetPermission(FsAction.ReadExecute
).SetScope(AclEntryScope.Access).SetType(AclEntryType.User).Build();
fs.ModifyAclEntries(p, Lists.NewArrayList(e));
Restart(fs, persistNamespace);
AclStatus s = cluster.GetNamesystem().GetAclStatus(p.ToString());
AclEntry[] returned = Sharpen.Collections.ToArray(Lists.NewArrayList(s.GetEntries
()), new AclEntry[0]);
Assert.AssertArrayEquals(new AclEntry[] { AclTestHelpers.AclEntry(AclEntryScope.Access
, AclEntryType.User, "foo", FsAction.ReadExecute), AclTestHelpers.AclEntry(AclEntryScope
.Access, AclEntryType.Group, FsAction.Read) }, returned);
fs.RemoveAcl(p);
if (persistNamespace)
{
fs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeEnter);
fs.SaveNamespace();
fs.SetSafeMode(HdfsConstants.SafeModeAction.SafemodeLeave);
}
cluster.RestartNameNode();
cluster.WaitActive();
s = cluster.GetNamesystem().GetAclStatus(p.ToString());
returned = Sharpen.Collections.ToArray(Lists.NewArrayList(s.GetEntries()), new AclEntry
[0]);
Assert.AssertArrayEquals(new AclEntry[] { }, returned);
fs.ModifyAclEntries(p, Lists.NewArrayList(e));
s = cluster.GetNamesystem().GetAclStatus(p.ToString());
returned = Sharpen.Collections.ToArray(Lists.NewArrayList(s.GetEntries()), new AclEntry
[0]);
Assert.AssertArrayEquals(new AclEntry[] { AclTestHelpers.AclEntry(AclEntryScope.Access
, AclEntryType.User, "foo", FsAction.ReadExecute), AclTestHelpers.AclEntry(AclEntryScope
.Access, AclEntryType.Group, FsAction.Read) }, returned);
}
/// <summary>Prints all the ACL entries in a single scope.</summary>
/// <param name="aclStatus">AclStatus for the path</param>
/// <param name="fsPerm">FsPermission for the path</param>
/// <param name="entries">List<AclEntry> containing ACL entries of file</param>
private void PrintAclEntriesForSingleScope(AclStatus aclStatus, FsPermission fsPerm
, IList <AclEntry> entries)
{
if (entries.IsEmpty())
{
return;
}
if (AclUtil.IsMinimalAcl(entries))
{
foreach (AclEntry entry in entries)
{
@out.WriteLine(entry);
}
}
else
{
foreach (AclEntry entry in entries)
{
PrintExtendedAclEntry(aclStatus, fsPerm, entry);
}
}
}
/// <exception cref="System.IO.IOException"/>
protected internal override void ProcessPath(PathData item)
{
@out.WriteLine("# file: " + item);
@out.WriteLine("# owner: " + item.stat.GetOwner());
@out.WriteLine("# group: " + item.stat.GetGroup());
FsPermission perm = item.stat.GetPermission();
if (perm.GetStickyBit())
{
@out.WriteLine("# flags: --" + (perm.GetOtherAction().Implies(FsAction.Execute) ?
"t" : "T"));
}
AclStatus aclStatus = item.fs.GetAclStatus(item.path);
IList <AclEntry> entries = perm.GetAclBit() ? aclStatus.GetEntries() : Collections
.EmptyList <AclEntry>();
ScopedAclEntries scopedEntries = new ScopedAclEntries(AclUtil.GetAclFromPermAndEntries
(perm, entries));
PrintAclEntriesForSingleScope(aclStatus, perm, scopedEntries.GetAccessEntries());
PrintAclEntriesForSingleScope(aclStatus, perm, scopedEntries.GetDefaultEntries());
@out.WriteLine();
}
/// <summary>
/// Simple ACL tests on a file: Set an acl, add an acl, remove one acl,
/// and remove all acls.
/// </summary>
/// <exception cref="System.Exception"/>
private void TestFileAcls()
{
if (IsLocalFS())
{
return;
}
string aclUser1 = "user:foo:rw-";
string aclUser2 = "user:bar:r--";
string aclGroup1 = "group::r--";
string aclSet = "user::rwx," + aclUser1 + "," + aclGroup1 + ",other::---";
FileSystem proxyFs = FileSystem.Get(GetProxiedFSConf());
FileSystem httpfs = GetHttpFSFileSystem();
Path path = new Path(GetProxiedFSTestDir(), "testAclStatus.txt");
OutputStream os = proxyFs.Create(path);
os.Write(1);
os.Close();
AclStatus proxyAclStat = proxyFs.GetAclStatus(path);
AclStatus httpfsAclStat = httpfs.GetAclStatus(path);
AssertSameAcls(httpfsAclStat, proxyAclStat);
httpfs.SetAcl(path, AclEntry.ParseAclSpec(aclSet, true));
proxyAclStat = proxyFs.GetAclStatus(path);
httpfsAclStat = httpfs.GetAclStatus(path);
AssertSameAcls(httpfsAclStat, proxyAclStat);
httpfs.ModifyAclEntries(path, AclEntry.ParseAclSpec(aclUser2, true));
proxyAclStat = proxyFs.GetAclStatus(path);
httpfsAclStat = httpfs.GetAclStatus(path);
AssertSameAcls(httpfsAclStat, proxyAclStat);
httpfs.RemoveAclEntries(path, AclEntry.ParseAclSpec(aclUser1, true));
proxyAclStat = proxyFs.GetAclStatus(path);
httpfsAclStat = httpfs.GetAclStatus(path);
AssertSameAcls(httpfsAclStat, proxyAclStat);
httpfs.RemoveAcl(path);
proxyAclStat = proxyFs.GetAclStatus(path);
httpfsAclStat = httpfs.GetAclStatus(path);
AssertSameAcls(httpfsAclStat, proxyAclStat);
}
// Creates an entry for a new file or directory.
private DirectoryEntryMetaData CreateMetaData(string entryName, DirectoryEntryType type, string octalPermission)
{
var entry = new DirectoryEntry(entryName)
{
Permission = octalPermission ?? "770",
LastAccessTime = DateTime.UtcNow,
LastModifiedTime = DateTime.UtcNow,
Type = type,
ExpiryTime = null,
User = Owner,
Group = Group
};
var aclStatus = new AclStatus(new List <AclEntry>(), Owner, Group, octalPermission ?? "770", false);
var metaData = new DirectoryEntryMetaData()
{
DataStream = type == DirectoryEntryType.FILE?new MemoryStream():null,
Entry = entry,
AclData = aclStatus,
CreationTime = DateTime.UtcNow
};
return(metaData);
}
internal static DataLakeStoreItemAce[] GetAclFromStatus(AclStatus aclStatus)
{
var toReturn = new DataLakeStoreItemAce[aclStatus.Entries.Count()];
var index = 0;
foreach(var entry in aclStatus.Entries)
{
toReturn[index++] = Parse(entry);
}
return toReturn;
}
public async Task GetAccessControlAsync(string fullPath)
{
AdlsClient client = await GetAdlsClientAsync().ConfigureAwait(false);
AclStatus acl = await client.GetAclStatusAsync(fullPath, UserGroupRepresentation.ObjectID).ConfigureAwait(false);
}
internal void InitializeAces(AclStatus aclStatus)
{
GroupAces = new Hashtable();
UserAces = new Hashtable();
DefaultGroupAces = new Hashtable();
DefaultUserAces = new Hashtable();
foreach (var entry in aclStatus.Entries)
{
var isDefaultAce = false;
var typeIndex = 0;
var singleSpec = entry.Split(':');
if (singleSpec.Length == 4 && singleSpec[0].ToLowerInvariant().Equals("default"))
{
isDefaultAce = true;
typeIndex = 1;
}
else if (singleSpec.Length != 3)
{
throw new CloudException(string.Format(Resources.InvalidAce, entry));
}
switch (singleSpec[typeIndex].ToLowerInvariant())
{
case "group":
if (isDefaultAce && !string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default groups
DefaultGroupAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
else if (isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default owning group permissions
DefaultOwningGroupPermission = singleSpec[typeIndex + 2];
}
else if (!isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// owning group permissions
OwningGroupPermission = singleSpec[typeIndex + 2];
}
else
{
// regular groups
GroupAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
break;
case "user":
if (isDefaultAce && !string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default users
DefaultUserAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
else if (isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default owner permissions
DefaultOwnerPermission = singleSpec[typeIndex + 2];
}
else if (!isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// owner permissions
OwnerPermission = singleSpec[typeIndex + 2];
}
else
{
// user aces
UserAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
break;
case "mask":
MaskPermission = singleSpec[typeIndex + 2];
break;
case "other":
OtherPermission = singleSpec[typeIndex + 2];
break;
default:
throw new CloudException(string.Format(Resources.InvalidAce, entry));
}
}
IsInitialized = true;
}
internal static DataLakeStoreItemAce[] GetAclFromStatus(AclStatus aclStatus)
{
return(aclStatus.Entries.Select(entry => new DataLakeStoreItemAce(entry)).ToArray());
}
/// <summary>Simple constructor</summary>
/// <param name="fileStatus">Existing FileStatus object</param>
/// <param name="aclStatus">Existing AclStatus object</param>
public StatusPair(FileStatus fileStatus, AclStatus aclStatus)
{
this.fileStatus = fileStatus;
this.aclStatus = aclStatus;
}
/// <summary>Executes the filesystem operation.</summary>
/// <param name="fs">filesystem instance to use.</param>
/// <returns>a Map object (JSON friendly) with the file status.</returns>
/// <exception cref="System.IO.IOException">thrown if an IO error occurred.</exception>
public virtual IDictionary Execute(FileSystem fs)
{
AclStatus status = fs.GetAclStatus(path);
return(AclStatusToJSON(status));
}
internal void InitializeAces(AclStatus aclStatus)
{
GroupAces = new Hashtable();
UserAces = new Hashtable();
DefaultGroupAces = new Hashtable();
DefaultUserAces = new Hashtable();
foreach (var entry in aclStatus.Entries)
{
var isDefaultAce = false;
var typeIndex = 0;
var singleSpec = entry.Split(':');
if (singleSpec.Length == 4 && singleSpec[0].ToLowerInvariant().Equals("default"))
{
isDefaultAce = true;
typeIndex = 1;
}
else if (singleSpec.Length != 3)
{
throw new CloudException(string.Format(Resources.InvalidAce, entry));
}
switch (singleSpec[typeIndex].ToLowerInvariant())
{
case "group":
if (isDefaultAce && !string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default groups
DefaultGroupAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
else if (isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default owning group permissions
DefaultOwningGroupPermission = singleSpec[typeIndex + 2];
}
else if (!isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// owning group permissions
OwningGroupPermission = singleSpec[typeIndex + 2];
}
else
{
// regular groups
GroupAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
break;
case "user":
if (isDefaultAce && !string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default users
DefaultUserAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
else if (isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// default owner permissions
DefaultOwnerPermission = singleSpec[typeIndex + 2];
}
else if (!isDefaultAce && string.IsNullOrEmpty(singleSpec[typeIndex + 1]))
{
// owner permissions
OwnerPermission = singleSpec[typeIndex + 2];
}
else
{
// user aces
UserAces.Add(singleSpec[typeIndex + 1], singleSpec[typeIndex + 2]);
}
break;
case "mask":
MaskPermission = singleSpec[typeIndex + 2];
break;
case "other":
OtherPermission = singleSpec[typeIndex + 2];
break;
default:
throw new CloudException(string.Format(Resources.InvalidAce, entry));
}
}
IsInitialized = true;
}
private AclEntry[] AclEntryArray(AclStatus aclStatus)
{
return(Sharpen.Collections.ToArray(aclStatus.GetEntries(), new AclEntry[0]));
}
