/// <summary>
/// It is used to check if the current object is equal to another object.
/// </summary>
/// <param name="obj"></param>
/// <returns>It returns true if the objects are equal else false.</returns>
public override bool Equals(object obj)
{
//Check for null and compare run-time types.
if ((obj == null) || !this.GetType().Equals(obj.GetType()))
{
return(false);
}
else
{
Node node = (Node)obj;
if (node.Type == NodeType.NumberNode)
{
return(Value == node.Value);
}
else if (node.Type == NodeType.PlusNode || node.Type == NodeType.MinusNode || node.Type == NodeType.FactorialNode)
{
return(Type.Equals(node.Type) && NodeA.Equals(node.NodeA));
}
else if (node.Type == NodeType.EmptyNode)
{
return(Type.Equals(node.Type));
}
return(Type.Equals(node.Type) && NodeA.Equals(node.NodeA) && NodeB.Equals(node.NodeB));
}
}
protected override INode CreateNode(INodeAddress address, NodeType nodeType)
{
lock (this)
{
string path;
if (nodeType.Equals(NodeType.File))
{
path = ((AbstractNodeAddressWithRootPart)address).AbsolutePathIncludingRootPart;
return(new ZipFile(this, (LayeredNodeAddress)address, GetEntry(path)));
}
else if (nodeType.Equals(NodeType.Directory))
{
path = ((AbstractNodeAddressWithRootPart)address).AbsolutePathIncludingRootPart;
if (path != FileSystemManager.SeperatorString)
{
path += "/";
}
return(new ZipDirectory(this, (LayeredNodeAddress)address, GetEntry(path)));
}
else
{
throw new NotSupportedException(nodeType.ToString());
}
}
}
public override IEnumerable <INode> DoGetChildren(NodeType nodeType, Predicate <INode> acceptNode)
{
INode node;
var files = new List <IFile>();
var directories = new HashSet <string>();
Refresh();
var fileSystem = (ZipFileSystem)this.FileSystem;
foreach (ZLib.ZipEntry zipEntry in fileSystem.zipFile)
{
if (zipEntry.Name.StartsWith(this.ZipPath) && /* Is descendent */
zipEntry.Name.Length != this.ZipPath.Length /* Not self */)
{
var x = zipEntry.Name.IndexOf('/', this.ZipPath.Length + 1);
if (x == -1 /* Is direct descendent File */)
{
node = this.FileSystem.ResolveFile(FileSystemManager.SeperatorChar + zipEntry.Name);
if (acceptNode(node))
{
files.Add((IFile)node);
}
}
else if (x <= zipEntry.Name.Length - 1 /* Is direct descendent dir */)
{
var s = zipEntry.Name.Substring(0, x);
directories.Add(s);
}
}
}
if (nodeType.Equals(NodeType.Directory) || nodeType.Equals(NodeType.Any))
{
var sortedDirectories = directories.Sorted(StringComparer.InvariantCultureIgnoreCase);
foreach (var path in sortedDirectories)
{
node = this.FileSystem.ResolveDirectory(FileSystemManager.SeperatorChar + path);
if (acceptNode(node))
{
yield return(node);
}
}
}
if (nodeType.Equals(NodeType.File) || nodeType.Equals(NodeType.Any))
{
foreach (var file in files)
{
yield return(file);
}
}
}
private IEnumerable <string> PrivateGetChildNames(NodeType nodeType)
{
if (nodeType.Equals(NodeType.File) || nodeType.Equals(NodeType.Any))
{
string[] names;
foreach (string s in this.GetJumpPointNames(NodeType.File))
{
yield return(s);
}
try
{
names = Directory.GetFiles(this.directoryInfo.FullName);
}
catch (DirectoryNotFoundException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (string s in names)
{
if (!this.ContainsShortcut(s, NodeType.File))
{
yield return(Path.GetFileName(s));
}
}
}
if (nodeType.Equals(NodeType.Directory) || nodeType.Equals(NodeType.Any))
{
string[] names;
foreach (var s in this.GetJumpPointNames(NodeType.Directory))
{
yield return(s);
}
try
{
names = Directory.GetDirectories(this.directoryInfo.FullName);
}
catch (System.IO.DirectoryNotFoundException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (var s in names)
{
if (!this.ContainsShortcut(s, NodeType.Directory))
{
yield return(Path.GetFileName(s));
}
}
}
}
public virtual RMContainer Allocate(NodeType type, FSSchedulerNode node, Priority
priority, ResourceRequest request, Container container)
{
lock (this)
{
// Update allowed locality level
NodeType allowed = allowedLocalityLevel[priority];
if (allowed != null)
{
if (allowed.Equals(NodeType.OffSwitch) && (type.Equals(NodeType.NodeLocal) || type
.Equals(NodeType.RackLocal)))
{
this.ResetAllowedLocalityLevel(priority, type);
}
else
{
if (allowed.Equals(NodeType.RackLocal) && type.Equals(NodeType.NodeLocal))
{
this.ResetAllowedLocalityLevel(priority, type);
}
}
}
// Required sanity check - AM can call 'allocate' to update resource
// request without locking the scheduler, hence we need to check
if (GetTotalRequiredResources(priority) <= 0)
{
return(null);
}
// Create RMContainer
RMContainer rmContainer = new RMContainerImpl(container, GetApplicationAttemptId(
), node.GetNodeID(), appSchedulingInfo.GetUser(), rmContext);
// Add it to allContainers list.
newlyAllocatedContainers.AddItem(rmContainer);
liveContainers[container.GetId()] = rmContainer;
// Update consumption and track allocations
IList <ResourceRequest> resourceRequestList = appSchedulingInfo.Allocate(type, node
, priority, request, container);
Resources.AddTo(currentConsumption, container.GetResource());
// Update resource requests related to "request" and store in RMContainer
((RMContainerImpl)rmContainer).SetResourceRequests(resourceRequestList);
// Inform the container
rmContainer.Handle(new RMContainerEvent(container.GetId(), RMContainerEventType.Start
));
if (Log.IsDebugEnabled())
{
Log.Debug("allocate: applicationAttemptId=" + container.GetId().GetApplicationAttemptId
() + " container=" + container.GetId() + " host=" + container.GetNodeId().GetHost
() + " type=" + type);
}
RMAuditLogger.LogSuccess(GetUser(), RMAuditLogger.AuditConstants.AllocContainer,
"SchedulerApp", GetApplicationId(), container.GetId());
return(rmContainer);
}
}
/// <summary>Return the level at which we are allowed to schedule containers.</summary>
/// <remarks>
/// Return the level at which we are allowed to schedule containers.
/// Given the thresholds indicating how much time passed before relaxing
/// scheduling constraints.
/// </remarks>
public virtual NodeType GetAllowedLocalityLevelByTime(Priority priority, long nodeLocalityDelayMs
, long rackLocalityDelayMs, long currentTimeMs)
{
lock (this)
{
// if not being used, can schedule anywhere
if (nodeLocalityDelayMs < 0 || rackLocalityDelayMs < 0)
{
return(NodeType.OffSwitch);
}
// default level is NODE_LOCAL
if (!allowedLocalityLevel.Contains(priority))
{
allowedLocalityLevel[priority] = NodeType.NodeLocal;
return(NodeType.NodeLocal);
}
NodeType allowed = allowedLocalityLevel[priority];
// if level is already most liberal, we're done
if (allowed.Equals(NodeType.OffSwitch))
{
return(NodeType.OffSwitch);
}
// check waiting time
long waitTime = currentTimeMs;
if (lastScheduledContainer.Contains(priority))
{
waitTime -= lastScheduledContainer[priority];
}
else
{
waitTime -= GetStartTime();
}
long thresholdTime = allowed.Equals(NodeType.NodeLocal) ? nodeLocalityDelayMs : rackLocalityDelayMs;
if (waitTime > thresholdTime)
{
if (allowed.Equals(NodeType.NodeLocal))
{
allowedLocalityLevel[priority] = NodeType.RackLocal;
ResetSchedulingOpportunities(priority, currentTimeMs);
}
else
{
if (allowed.Equals(NodeType.RackLocal))
{
allowedLocalityLevel[priority] = NodeType.OffSwitch;
ResetSchedulingOpportunities(priority, currentTimeMs);
}
}
}
return(allowedLocalityLevel[priority]);
}
}
/// <summary>
/// Return the level at which we are allowed to schedule containers, given the
/// current size of the cluster and thresholds indicating how many nodes to
/// fail at (as a fraction of cluster size) before relaxing scheduling
/// constraints.
/// </summary>
public virtual NodeType GetAllowedLocalityLevel(Priority priority, int numNodes,
double nodeLocalityThreshold, double rackLocalityThreshold)
{
lock (this)
{
// upper limit on threshold
if (nodeLocalityThreshold > 1.0)
{
nodeLocalityThreshold = 1.0;
}
if (rackLocalityThreshold > 1.0)
{
rackLocalityThreshold = 1.0;
}
// If delay scheduling is not being used, can schedule anywhere
if (nodeLocalityThreshold < 0.0 || rackLocalityThreshold < 0.0)
{
return(NodeType.OffSwitch);
}
// Default level is NODE_LOCAL
if (!allowedLocalityLevel.Contains(priority))
{
allowedLocalityLevel[priority] = NodeType.NodeLocal;
return(NodeType.NodeLocal);
}
NodeType allowed = allowedLocalityLevel[priority];
// If level is already most liberal, we're done
if (allowed.Equals(NodeType.OffSwitch))
{
return(NodeType.OffSwitch);
}
double threshold = allowed.Equals(NodeType.NodeLocal) ? nodeLocalityThreshold : rackLocalityThreshold;
// Relax locality constraints once we've surpassed threshold.
if (GetSchedulingOpportunities(priority) > (numNodes * threshold))
{
if (allowed.Equals(NodeType.NodeLocal))
{
allowedLocalityLevel[priority] = NodeType.RackLocal;
ResetSchedulingOpportunities(priority);
}
else
{
if (allowed.Equals(NodeType.RackLocal))
{
allowedLocalityLevel[priority] = NodeType.OffSwitch;
ResetSchedulingOpportunities(priority);
}
}
}
return(allowedLocalityLevel[priority]);
}
}
public void OnValidate()
{
if (dialogueNodeType.Equals(NodeType.branch))
{
// If the branch node has text, remove it.
if (!dialogueText.Equals(""))
{
dialogueText = "";
}
// If the number of child nodes is greater than four, we have a problem.
if (childNodes.Count > 4)
{
dialogueNodeType = NodeType.error;
return;
}
else
{
// If the children do not have the proper condition (none), we have a problem.
foreach (DialogueBranchCondition dbc in childNodes)
{
if (!dbc.condition.Equals(DialogueBranchCondition.Condition.none))
{
dialogueNodeType = NodeType.error;
return;
}
}
}
}
else if (dialogueNodeType.Equals(NodeType.single))
{
// If the children use the same condition more than once, we have a problem.
List <DialogueBranchCondition.Condition> conditions = new List <DialogueBranchCondition.Condition>();
foreach (DialogueBranchCondition dbc in childNodes)
{
if (!conditions.Contains(dbc.condition))
{
conditions.Add(dbc.condition);
}
else
{
dialogueNodeType = NodeType.error;
return;
}
}
}
// Check to make sure there are no invalid IDs in the child nodes.
((DialogueTree)graph).ValidateNode(this);
}
/// <summary>
/// Creates the node.
/// </summary>
/// <param name="address">The address.</param>
/// <param name="nodeType">Type of the node.</param>
/// <returns></returns>
protected override INode CreateNode(INodeAddress address, NodeType nodeType)
{
lock (this)
{
if (nodeType.Equals(NodeType.File))
return new PgpFile(this, address, ParentLayer);
throw new NodeTypeNotSupportedException(nodeType);
}
}
public Node(Point point, NodeType n, String name, int localPort, int mPort, int ccrcPort, int nccPort = 0)
{
nodeType = n;
if (n.Equals(NodeType.CLIENT))
{
this.Name = name;
this.LocalPort = localPort;
this.Position = point;
this.ManagmentPort = mPort;
this.CcRcPort = ccrcPort;
this.NccPort = nccPort;
String parameters = name + " " + this.LocalPort + " " + this.ManagmentPort + " " + this.NccPort;
ProcessStartInfo startInfo = new ProcessStartInfo("ClientNode.exe");
startInfo.WindowStyle = ProcessWindowStyle.Minimized;
startInfo.Arguments = parameters;
this.ProcessHandle = Process.Start(startInfo);
Thread.Sleep(100);
Program.SwitchToThisWindow(Process.GetCurrentProcess().MainWindowHandle, true);
}
else if (n.Equals(NodeType.NETWORK))
{
this.Name = name;
this.LocalPort = localPort;
this.Position = point;
this.ManagmentPort = mPort;
this.CcRcPort = ccrcPort;
String parameters = name + " " + this.LocalPort + " " + this.ManagmentPort + " " + this.CcRcPort;
ProcessStartInfo startInfo = new ProcessStartInfo("NetNode.exe");
startInfo.WindowStyle = ProcessWindowStyle.Minimized;
startInfo.Arguments = parameters;
this.ProcessHandle = Process.Start(startInfo);
Thread.Sleep(50);
Program.SwitchToThisWindow(Process.GetCurrentProcess().MainWindowHandle, true);
}
//Thread.Sleep(100);
//System.Diagnostics.Process me = System.Diagnostics.Process.GetCurrentProcess();
//Program.SwitchToThisWindow(me.MainWindowHandle, true);
}
public void Reset()
{
F = G = H = 0;
parent = null;
state = NodeState.None;
if (type.Equals(NodeType.Route))
{
type = NodeType.Movable;
}
}
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
string value;
canCache = false;
if (this.QueryKey == null)
{
value = "true";
}
else
{
try
{
if (address.QueryValues[QueryKey] == null)
{
return(null);
}
value = (string)address.QueryValues[this.QueryKey];
}
catch (KeyNotFoundException)
{
value = null;
}
}
if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true")
{
canCache = true;
var innerNodeType = nodeType.InnerType;
if (innerNodeType == null)
{
innerNodeType = NodeType.File;
}
var query = StringUriUtils.BuildQuery
(
address.QueryValues,
QueryFilter
);
var uri = address.AbsolutePath + "?" + query;
return(new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address));
}
return(null);
}
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache)
{
string value;
canCache = false;
if (this.QueryKey == null)
{
value = "true";
}
else
{
try
{
if (address.QueryValues[QueryKey] == null)
{
return null;
}
value = (string)address.QueryValues[this.QueryKey];
}
catch (KeyNotFoundException)
{
value = null;
}
}
if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true")
{
canCache = true;
var innerNodeType = nodeType.InnerType;
if (innerNodeType == null)
{
innerNodeType = NodeType.File;
}
var query = StringUriUtils.BuildQuery
(
address.QueryValues,
QueryFilter
);
var uri = address.AbsolutePath + "?" + query;
return new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address);
}
return null;
}
public override IEnumerable <INode> DoGetChildren(NodeType nodeType, Predicate <INode> acceptNode)
{
bool localRefreshNodes;
lock (this.SyncLock)
{
localRefreshNodes = this.refreshNodes;
this.refreshNodes = false;
}
localRefreshNodes = true;
/**
* TODO: If refreshNodes is true then we have to manually refresh
* all children that aren't listed in the current listing but are
* still in the node cache.
*
* Do this by attaching to cache events (thru a weak event handler) and
* keeping a list of all cached (and thus resolved) nodes that are children
* of this node.
*/
//lock (this.SyncLock)
{
string[] items;
foreach (var jumpPoint in GetJumpPoints(NodeType.Directory))
{
yield return(jumpPoint);
}
if ((nodeType.Equals(NodeType.Directory)) || nodeType.Equals(NodeType.Any))
{
try
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
// Hack for mono which does not return symbolic links as directories anymore
items = Directory.GetFileSystemEntries(this.directoryInfo.FullName);
}
else
{
items = Directory.GetDirectories(this.directoryInfo.FullName);
}
}
catch (System.IO.IOException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (var name in items)
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
if (Native.GetInstance().GetSymbolicLinkTarget(name) != null)
{
if (Native.GetInstance().GetSymbolicLinkTargetType(name) != NodeType.Directory)
{
continue;
}
}
else
{
if (!Directory.Exists(name))
{
continue;
}
}
}
var dir = (IDirectory)this.FileSystem.Resolve(this.Address.ResolveAddress(Path.GetFileName(name)), NodeType.Directory);
if (localRefreshNodes && !String.Equals((string)dir.Attributes["DriveType"], "Removable", StringComparison.CurrentCultureIgnoreCase))
{
dir.Refresh();
}
if (!ContainsShortcut(dir.Name, NodeType.Directory))
{
if (acceptNode(dir))
{
yield return(dir);
}
}
}
}
foreach (INode jumpPoint in GetJumpPoints(NodeType.File))
{
yield return(jumpPoint);
}
if ((nodeType.Equals(NodeType.File)) || nodeType.Equals(NodeType.Any))
{
try
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
items = Directory.GetFileSystemEntries(this.directoryInfo.FullName);
}
else
{
items = Directory.GetFiles(this.directoryInfo.FullName);
}
}
catch (System.IO.DirectoryNotFoundException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (string name in items)
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
if (Native.GetInstance().GetSymbolicLinkTarget(name) != null)
{
if (Native.GetInstance().GetSymbolicLinkTargetType(name) != NodeType.File)
{
continue;
}
}
else
{
if (!File.Exists(name))
{
continue;
}
}
}
var file = (IFile)this.FileSystem.Resolve(this.Address.ResolveAddress(Path.GetFileName(name)), NodeType.File);
if (localRefreshNodes)
{
file.Refresh();
}
if (!ContainsShortcut(file.Name, NodeType.File))
{
if (acceptNode(file))
{
yield return(file);
}
}
}
}
localRefreshNodes = false;
}
}
public override IEnumerable<INode> DoGetChildren(NodeType nodeType, Predicate<INode> acceptNode)
{
var listedAllChildren = false;
IDictionary<string, INode> newChildren;
Pair<DirectoryRefreshMask, int> refreshInfo;
foreach (INode node in this.GetJumpPoints(nodeType, acceptNode))
{
yield return node;
}
var shouldLoadFromNetwork = false;
lock (this.SyncLock)
{
refreshInfo = this.directoryRefreshInfo;
if ((refreshInfo.Left & DirectoryRefreshMask.Children) != 0)
{
shouldLoadFromNetwork = true;
}
if (this.children == null)
{
this.children = new SortedDictionary<string, INode>(StringComparer.CurrentCultureIgnoreCase);
}
}
if (shouldLoadFromNetwork)
{
string regex = null;
var skipAcceptNode = false; ;
var toRemove = new List<string>();
var newAttributes = new Dictionary<string, object>(StringComparer.CurrentCultureIgnoreCase);
if (NetworkDirectory.threadLocalNewChildren == null)
{
NetworkDirectory.threadLocalNewChildren = new SortedDictionary<string, INode>(StringComparer.CurrentCultureIgnoreCase);
}
else
{
NetworkDirectory.threadLocalNewChildren.Clear();
}
newChildren = NetworkDirectory.threadLocalNewChildren;
try
{
if (RegexBasedNodePredicateHelper.IsRegexBasedNodePredicate(acceptNode)
/* Only load based on REGEX if not refreshing AllChildren */
&& refreshInfo.Left != DirectoryRefreshMask.AllChildren)
{
regex = RegexBasedNodePredicateHelper.GetRegexFromRegexBasedNodePredicate(acceptNode).ToString();
if (RegexBasedNodePredicateHelper.PredicateNameBasedOnly(acceptNode))
{
skipAcceptNode = true;
}
}
using (var freeClientContext = ((NetworkFileSystem)this.FileSystem).GetFreeClientContext())
{
var networkclient = freeClientContext.NetworkFileSystemClient;
IEnumerator<NetworkFileSystemEntry> enumerator;
var enumerable = networkclient.ListAttributes(this.Address.RemoteUri, regex);
using (enumerator = enumerable.GetEnumerator())
{
while (true)
{
try
{
if (!enumerator.MoveNext())
{
break;
}
}
catch (DirectoryNodeNotFoundException)
{
lock (this.SyncLock)
{
foreach (var node in this.children.Values)
{
((NetworkNodeAndFileAttributes)node.Attributes).Clear();
((NetworkNodeAndFileAttributes)node.Attributes).SetValue<bool>("exists", false);
}
this.children.Clear();
}
throw;
}
var entry = enumerator.Current;
INode child = null;
if (entry.NodeType == NodeType.Directory)
{
child = this.ResolveDirectory(entry.Name);
}
else
{
child = this.ResolveFile(entry.Name);
}
var attributes = (NetworkNodeAndFileAttributes)child.Attributes;
newAttributes.Clear();
foreach (var attribute in entry.ReadAttributes())
{
newAttributes[attribute.Key] = attribute.Value;
}
try
{
lock (attributes.SyncLock)
{
toRemove.Clear();
foreach (var attribute in newAttributes)
{
attributes.SetValue<object>(attribute.Key, attribute.Value);
}
foreach (var name in attributes.Names)
{
if (!newAttributes.ContainsKey(name))
{
toRemove.Add(name);
}
}
foreach (var name in toRemove)
{
attributes.SetValue<object>(name, null);
}
attributes.SetValue<bool>("exists", true);
}
newChildren.Add(child.Name, child);
}
catch (Exception)
{
Debugger.Break();
}
if ((nodeType.Equals(NodeType.Any) || child.NodeType.Equals(nodeType))
&& (skipAcceptNode || acceptNode(child)))
{
yield return child;
}
}
}
if (regex == null)
{
listedAllChildren = true;
}
}
}
finally
{
lock (this.SyncLock)
{
if (listedAllChildren)
{
toRemove.Clear();
foreach (var node in this.children.Values)
{
if (!newChildren.ContainsKey(node.Name))
{
((NetworkNodeAndFileAttributes)node.Attributes).Clear();
((NetworkNodeAndFileAttributes)node.Attributes).SetValue<bool>("exists", false);
toRemove.Add(node.Name);
}
}
foreach (var name in toRemove)
{
this.children.Remove(name);
}
if (this.directoryRefreshInfo.Right == refreshInfo.Right)
{
this.directoryRefreshInfo.Left = DirectoryRefreshMask.None;
}
}
foreach (var node in newChildren.Values)
{
this.children[node.Name] = node;
}
}
toRemove.Clear();
}
yield break;
}
else
{
var retvals = new List<INode>();
// Copy the children because we want to yield outside the lock
lock (this.SyncLock)
{
foreach (var pair in this.children)
{
if ((nodeType.Equals(NodeType.Any) || pair.Value.NodeType.Equals(nodeType)) && acceptNode(pair.Value))
{
retvals.Add(pair.Value);
}
}
}
foreach (var node in retvals)
{
yield return node;
}
}
}
public override IEnumerable<INode> DoGetChildren(NodeType nodeType, Predicate<INode> acceptNode)
{
INode node;
var files = new List<IFile>();
var directories = new HashSet<string>();
Refresh();
var fileSystem = (ZipFileSystem)this.FileSystem;
foreach (ZLib.ZipEntry zipEntry in fileSystem.zipFile)
{
if (zipEntry.Name.StartsWith(this.ZipPath) /* Is descendent */
&& zipEntry.Name.Length != this.ZipPath.Length /* Not self */)
{
var x = zipEntry.Name.IndexOf('/', this.ZipPath.Length + 1);
if (x == -1 /* Is direct descendent File */)
{
node = this.FileSystem.ResolveFile(FileSystemManager.SeperatorChar + zipEntry.Name);
if (acceptNode(node))
{
files.Add((IFile)node);
}
}
else if (x <= zipEntry.Name.Length - 1 /* Is direct descendent dir */)
{
var s = zipEntry.Name.Substring(0, x);
directories.Add(s);
}
}
}
if (nodeType.Equals(NodeType.Directory) || nodeType.Equals(NodeType.Any))
{
var sortedDirectories = directories.Sorted(StringComparer.InvariantCultureIgnoreCase);
foreach (var path in sortedDirectories)
{
node = this.FileSystem.ResolveDirectory(FileSystemManager.SeperatorChar + path);
if (acceptNode(node))
{
yield return node;
}
}
}
if (nodeType.Equals(NodeType.File) || nodeType.Equals(NodeType.Any))
{
foreach (var file in files)
{
yield return file;
}
}
}
public bool Equals(DestinyPresentationNodeDefinition input)
{
if (input == null)
{
return(false);
}
return
((
DisplayProperties == input.DisplayProperties ||
(DisplayProperties != null && DisplayProperties.Equals(input.DisplayProperties))
) &&
(
OriginalIcon == input.OriginalIcon ||
(OriginalIcon != null && OriginalIcon.Equals(input.OriginalIcon))
) &&
(
RootViewIcon == input.RootViewIcon ||
(RootViewIcon != null && RootViewIcon.Equals(input.RootViewIcon))
) &&
(
NodeType == input.NodeType ||
(NodeType != null && NodeType.Equals(input.NodeType))
) &&
(
Scope == input.Scope ||
(Scope != null && Scope.Equals(input.Scope))
) &&
(
ObjectiveHash == input.ObjectiveHash ||
(ObjectiveHash.Equals(input.ObjectiveHash))
) &&
(
CompletionRecordHash == input.CompletionRecordHash ||
(CompletionRecordHash.Equals(input.CompletionRecordHash))
) &&
(
Children == input.Children ||
(Children != null && Children.Equals(input.Children))
) &&
(
DisplayStyle == input.DisplayStyle ||
(DisplayStyle != null && DisplayStyle.Equals(input.DisplayStyle))
) &&
(
ScreenStyle == input.ScreenStyle ||
(ScreenStyle != null && ScreenStyle.Equals(input.ScreenStyle))
) &&
(
Requirements == input.Requirements ||
(Requirements != null && Requirements.Equals(input.Requirements))
) &&
(
DisableChildSubscreenNavigation == input.DisableChildSubscreenNavigation ||
(DisableChildSubscreenNavigation != null && DisableChildSubscreenNavigation.Equals(input.DisableChildSubscreenNavigation))
) &&
(
MaxCategoryRecordScore == input.MaxCategoryRecordScore ||
(MaxCategoryRecordScore.Equals(input.MaxCategoryRecordScore))
) &&
(
PresentationNodeType == input.PresentationNodeType ||
(PresentationNodeType != null && PresentationNodeType.Equals(input.PresentationNodeType))
) &&
(
TraitIds == input.TraitIds ||
(TraitIds != null && TraitIds.SequenceEqual(input.TraitIds))
) &&
(
TraitHashes == input.TraitHashes ||
(TraitHashes != null && TraitHashes.SequenceEqual(input.TraitHashes))
) &&
(
ParentNodeHashes == input.ParentNodeHashes ||
(ParentNodeHashes != null && ParentNodeHashes.SequenceEqual(input.ParentNodeHashes))
) &&
(
Hash == input.Hash ||
(Hash.Equals(input.Hash))
) &&
(
Index == input.Index ||
(Index.Equals(input.Index))
) &&
(
Redacted == input.Redacted ||
(Redacted != null && Redacted.Equals(input.Redacted))
));
}
private IEnumerable<string> PrivateGetChildNames(NodeType nodeType)
{
if (nodeType.Equals(NodeType.File) || nodeType.Equals(NodeType.Any))
{
string[] names;
foreach (string s in this.GetJumpPointNames(NodeType.File))
{
yield return s;
}
try
{
names = Directory.GetFiles(this.directoryInfo.FullName);
}
catch (DirectoryNotFoundException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (string s in names)
{
if (!this.ContainsShortcut(s, NodeType.File))
{
yield return Path.GetFileName(s);
}
}
}
if (nodeType.Equals(NodeType.Directory) || nodeType.Equals(NodeType.Any))
{
string[] names;
foreach (var s in this.GetJumpPointNames(NodeType.Directory))
{
yield return s;
}
try
{
names = Directory.GetDirectories(this.directoryInfo.FullName);
}
catch (System.IO.DirectoryNotFoundException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (var s in names)
{
if (!this.ContainsShortcut(s, NodeType.Directory))
{
yield return Path.GetFileName(s);
}
}
}
}
protected override INode CreateNode(INodeAddress address, NodeType nodeType)
{
lock (this)
{
string path;
if (nodeType.Equals(NodeType.File))
{
path = ((AbstractNodeAddressWithRootPart)address).AbsolutePathIncludingRootPart;
return new ZipFile(this, (LayeredNodeAddress)address, GetEntry(path));
}
else if (nodeType.Equals(NodeType.Directory))
{
path = ((AbstractNodeAddressWithRootPart)address).AbsolutePathIncludingRootPart;
if (path != FileSystemManager.SeperatorString)
{
path += "/";
}
return new ZipDirectory(this, (LayeredNodeAddress)address, GetEntry(path));
}
else
{
throw new NotSupportedException(nodeType.ToString());
}
}
}
public override IEnumerable <INode> DoGetChildren(NodeType nodeType, Predicate <INode> acceptNode)
{
var listedAllChildren = false;
IDictionary <string, INode> newChildren;
Pair <DirectoryRefreshMask, int> refreshInfo;
foreach (INode node in this.GetJumpPoints(nodeType, acceptNode))
{
yield return(node);
}
var shouldLoadFromNetwork = false;
lock (this.SyncLock)
{
refreshInfo = this.directoryRefreshInfo;
if ((refreshInfo.Left & DirectoryRefreshMask.Children) != 0)
{
shouldLoadFromNetwork = true;
}
if (this.children == null)
{
this.children = new SortedDictionary <string, INode>(StringComparer.CurrentCultureIgnoreCase);
}
}
if (shouldLoadFromNetwork)
{
string regex = null;
var skipAcceptNode = false;;
var toRemove = new List <string>();
var newAttributes = new Dictionary <string, object>(StringComparer.CurrentCultureIgnoreCase);
if (NetworkDirectory.threadLocalNewChildren == null)
{
NetworkDirectory.threadLocalNewChildren = new SortedDictionary <string, INode>(StringComparer.CurrentCultureIgnoreCase);
}
else
{
NetworkDirectory.threadLocalNewChildren.Clear();
}
newChildren = NetworkDirectory.threadLocalNewChildren;
try
{
if (RegexBasedNodePredicateHelper.IsRegexBasedNodePredicate(acceptNode)
/* Only load based on REGEX if not refreshing AllChildren */
&& refreshInfo.Left != DirectoryRefreshMask.AllChildren)
{
regex = RegexBasedNodePredicateHelper.GetRegexFromRegexBasedNodePredicate(acceptNode).ToString();
if (RegexBasedNodePredicateHelper.PredicateNameBasedOnly(acceptNode))
{
skipAcceptNode = true;
}
}
using (var freeClientContext = ((NetworkFileSystem)this.FileSystem).GetFreeClientContext())
{
var networkclient = freeClientContext.NetworkFileSystemClient;
IEnumerator <NetworkFileSystemEntry> enumerator;
var enumerable = networkclient.ListAttributes(this.Address.RemoteUri, regex);
using (enumerator = enumerable.GetEnumerator())
{
while (true)
{
try
{
if (!enumerator.MoveNext())
{
break;
}
}
catch (DirectoryNodeNotFoundException)
{
lock (this.SyncLock)
{
foreach (var node in this.children.Values)
{
((NetworkNodeAndFileAttributes)node.Attributes).Clear();
((NetworkNodeAndFileAttributes)node.Attributes).SetValue <bool>("exists", false);
}
this.children.Clear();
}
throw;
}
var entry = enumerator.Current;
INode child = null;
if (entry.NodeType == NodeType.Directory)
{
child = this.ResolveDirectory(entry.Name);
}
else
{
child = this.ResolveFile(entry.Name);
}
var attributes = (NetworkNodeAndFileAttributes)child.Attributes;
newAttributes.Clear();
foreach (var attribute in entry.ReadAttributes())
{
newAttributes[attribute.Key] = attribute.Value;
}
try
{
lock (attributes.SyncLock)
{
toRemove.Clear();
foreach (var attribute in newAttributes)
{
attributes.SetValue <object>(attribute.Key, attribute.Value);
}
foreach (var name in attributes.Names)
{
if (!newAttributes.ContainsKey(name))
{
toRemove.Add(name);
}
}
foreach (var name in toRemove)
{
attributes.SetValue <object>(name, null);
}
attributes.SetValue <bool>("exists", true);
}
newChildren.Add(child.Name, child);
}
catch (Exception)
{
Debugger.Break();
}
if ((nodeType.Equals(NodeType.Any) || child.NodeType.Equals(nodeType)) &&
(skipAcceptNode || acceptNode(child)))
{
yield return(child);
}
}
}
if (regex == null)
{
listedAllChildren = true;
}
}
}
finally
{
lock (this.SyncLock)
{
if (listedAllChildren)
{
toRemove.Clear();
foreach (var node in this.children.Values)
{
if (!newChildren.ContainsKey(node.Name))
{
((NetworkNodeAndFileAttributes)node.Attributes).Clear();
((NetworkNodeAndFileAttributes)node.Attributes).SetValue <bool>("exists", false);
toRemove.Add(node.Name);
}
}
foreach (var name in toRemove)
{
this.children.Remove(name);
}
if (this.directoryRefreshInfo.Right == refreshInfo.Right)
{
this.directoryRefreshInfo.Left = DirectoryRefreshMask.None;
}
}
foreach (var node in newChildren.Values)
{
this.children[node.Name] = node;
}
}
toRemove.Clear();
}
yield break;
}
else
{
var retvals = new List <INode>();
// Copy the children because we want to yield outside the lock
lock (this.SyncLock)
{
foreach (var pair in this.children)
{
if ((nodeType.Equals(NodeType.Any) || pair.Value.NodeType.Equals(nodeType)) && acceptNode(pair.Value))
{
retvals.Add(pair.Value);
}
}
}
foreach (var node in retvals)
{
yield return(node);
}
}
}
public override IEnumerable<INode> DoGetChildren(NodeType nodeType, Predicate<INode> acceptNode)
{
bool localRefreshNodes;
lock (this.SyncLock)
{
localRefreshNodes = this.refreshNodes;
this.refreshNodes = false;
}
localRefreshNodes = true;
/**
* TODO: If refreshNodes is true then we have to manually refresh
* all children that aren't listed in the current listing but are
* still in the node cache.
*
* Do this by attaching to cache events (thru a weak event handler) and
* keeping a list of all cached (and thus resolved) nodes that are children
* of this node.
*/
//lock (this.SyncLock)
{
string[] items;
foreach (var jumpPoint in GetJumpPoints(NodeType.Directory))
{
yield return jumpPoint;
}
if ((nodeType.Equals(NodeType.Directory)) || nodeType.Equals(NodeType.Any))
{
try
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
// Hack for mono which does not return symbolic links as directories anymore
items = Directory.GetFileSystemEntries(this.directoryInfo.FullName);
}
else
{
items = Directory.GetDirectories(this.directoryInfo.FullName);
}
}
catch (System.IO.IOException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (var name in items)
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
if (Native.GetInstance().GetSymbolicLinkTarget(name) != null)
{
if (Native.GetInstance().GetSymbolicLinkTargetType(name) != NodeType.Directory)
{
continue;
}
}
else
{
if (!Directory.Exists(name))
{
continue;
}
}
}
var dir = (IDirectory)this.FileSystem.Resolve(this.Address.ResolveAddress(Path.GetFileName(name)), NodeType.Directory);
if (localRefreshNodes && !String.Equals((string)dir.Attributes["DriveType"], "Removable", StringComparison.CurrentCultureIgnoreCase))
{
dir.Refresh();
}
if (!ContainsShortcut(dir.Name, NodeType.Directory))
{
if (acceptNode(dir))
{
yield return dir;
}
}
}
}
foreach (INode jumpPoint in GetJumpPoints(NodeType.File))
{
yield return jumpPoint;
}
if ((nodeType.Equals(NodeType.File)) || nodeType.Equals(NodeType.Any))
{
try
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
items = Directory.GetFileSystemEntries(this.directoryInfo.FullName);
}
else
{
items = Directory.GetFiles(this.directoryInfo.FullName);
}
}
catch (System.IO.DirectoryNotFoundException)
{
throw new DirectoryNodeNotFoundException(this.Address);
}
foreach (string name in items)
{
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
if (Native.GetInstance().GetSymbolicLinkTarget(name) != null)
{
if (Native.GetInstance().GetSymbolicLinkTargetType(name) != NodeType.File)
{
continue;
}
}
else
{
if (!File.Exists(name))
{
continue;
}
}
}
var file = (IFile)this.FileSystem.Resolve(this.Address.ResolveAddress(Path.GetFileName(name)), NodeType.File);
if (localRefreshNodes)
{
file.Refresh();
}
if (!ContainsShortcut(file.Name, NodeType.File))
{
if (acceptNode(file))
{
yield return file;
}
}
}
}
localRefreshNodes = false;
}
}
