/// <summary>
/// Changes the current working directory to the path specified.
/// </summary>
/// <param name="path">
/// The path of the new current working directory.
/// </param>
/// <param name="context">
/// The context the provider uses when performing the operation.
/// </param>
/// <param name="literalPath">
/// Indicate if the path is a literal path.
/// </param>
/// <returns>
/// The PathInfo object representing the path of the location
/// that was set.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="path"/> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If <paramref name="path"/> does not exist, is not a container, or
/// resolved to multiple containers.
/// </exception>
/// <exception cref="ProviderNotFoundException">
/// If <paramref name="path"/> refers to a provider that does not exist.
/// </exception>
/// <exception cref="DriveNotFoundException">
/// If <paramref name="path"/> refers to a drive that does not exist.
/// </exception>
/// <exception cref="ProviderInvocationException">
/// If the provider associated with <paramref name="path"/> threw an
/// exception.
/// </exception>
/// <exception cref="ItemNotFoundException">
/// If the <paramref name="path"/> could not be resolved.
/// </exception>
internal PathInfo SetLocation(string path, CmdletProviderContext context, bool literalPath)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
PathInfo current = CurrentLocation;
string originalPath = path;
string driveName = null;
ProviderInfo provider = null;
string providerId = null;
switch (originalPath)
{
case string originalPathSwitch when !literalPath && originalPathSwitch.Equals("-", StringComparison.Ordinal):
if (_setLocationHistory.UndoCount <= 0)
{
throw new InvalidOperationException(SessionStateStrings.LocationUndoStackIsEmpty);
}
path = _setLocationHistory.Undo(this.CurrentLocation).Path;
break;
case string originalPathSwitch when !literalPath && originalPathSwitch.Equals("+", StringComparison.Ordinal):
if (_setLocationHistory.RedoCount <= 0)
{
throw new InvalidOperationException(SessionStateStrings.LocationRedoStackIsEmpty);
}
path = _setLocationHistory.Redo(this.CurrentLocation).Path;
break;
default:
var pushPathInfo = GetNewPushPathInfo();
_setLocationHistory.Push(pushPathInfo);
break;
}
PSDriveInfo previousWorkingDrive = CurrentDrive;
// First check to see if the path is a home path
if (LocationGlobber.IsHomePath(path))
{
path = Globber.GetHomeRelativePath(path);
}
if (LocationGlobber.IsProviderDirectPath(path))
{
// The path is a provider-direct path so use the current
// provider and its hidden drive but don't modify the path
// at all.
provider = CurrentLocation.Provider;
CurrentDrive = provider.HiddenDrive;
}
else if (LocationGlobber.IsProviderQualifiedPath(path, out providerId))
{
provider = GetSingleProvider(providerId);
CurrentDrive = provider.HiddenDrive;
}
else
{
// See if the path is a relative or absolute
// path.
if (Globber.IsAbsolutePath(path, out driveName))
{
// Since the path is an absolute path
// we need to change the current working
// drive
PSDriveInfo newWorkingDrive = GetDrive(driveName);
CurrentDrive = newWorkingDrive;
// If the path is simply a colon-terminated drive,
// not a slash-terminated path to the root of a drive,
// set the path to the current working directory of that drive.
string colonTerminatedVolume = CurrentDrive.Name + ':';
if (CurrentDrive.VolumeSeparatedByColon && (path.Length == colonTerminatedVolume.Length))
{
path = Path.Combine(colonTerminatedVolume + Path.DirectorySeparatorChar, CurrentDrive.CurrentLocation);
}
// Now that the current working drive is set,
// process the rest of the path as a relative path.
}
}
if (context == null)
{
context = new CmdletProviderContext(this.ExecutionContext);
}
if (CurrentDrive != null)
{
context.Drive = CurrentDrive;
}
CmdletProvider providerInstance = null;
Collection <PathInfo> workingPath = null;
try
{
workingPath =
Globber.GetGlobbedMonadPathsFromMonadPath(
path,
false,
context,
out providerInstance);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception)
{
// Reset the drive to the previous drive and
// then rethrow the error
CurrentDrive = previousWorkingDrive;
throw;
}
if (workingPath.Count == 0)
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
throw
new ItemNotFoundException(
path,
"PathNotFound",
SessionStateStrings.PathNotFound);
}
// We allow globbing the location as long as it only resolves a single container.
bool foundContainer = false;
bool pathIsContainer = false;
bool pathIsProviderQualifiedPath = false;
bool currentPathisProviderQualifiedPath = false;
for (int index = 0; index < workingPath.Count; ++index)
{
CmdletProviderContext normalizePathContext =
new CmdletProviderContext(context);
PathInfo resolvedPath = workingPath[index];
string currentPath = path;
try
{
string providerName = null;
currentPathisProviderQualifiedPath = LocationGlobber.IsProviderQualifiedPath(resolvedPath.Path, out providerName);
if (currentPathisProviderQualifiedPath)
{
// The path should be the provider-qualified path without the provider ID
// or ::
string providerInternalPath = LocationGlobber.RemoveProviderQualifier(resolvedPath.Path);
try
{
currentPath = NormalizeRelativePath(GetSingleProvider(providerName), providerInternalPath, string.Empty, normalizePathContext);
}
catch (NotSupportedException)
{
// Since the provider does not support normalizing the path, just
// use the path we currently have.
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception)
{
// Reset the drive to the previous drive and
// then rethrow the error
CurrentDrive = previousWorkingDrive;
throw;
}
}
else
{
try
{
currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext);
}
catch (NotSupportedException)
{
// Since the provider does not support normalizing the path, just
// use the path we currently have.
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception)
{
// Reset the drive to the previous drive and
// then rethrow the error
CurrentDrive = previousWorkingDrive;
throw;
}
}
// Now see if there was errors while normalizing the path
if (normalizePathContext.HasErrors())
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
normalizePathContext.ThrowFirstErrorOrDoNothing();
}
}
finally
{
normalizePathContext.RemoveStopReferral();
}
bool isContainer = false;
CmdletProviderContext itemContainerContext =
new CmdletProviderContext(context);
itemContainerContext.SuppressWildcardExpansion = true;
try
{
isContainer =
IsItemContainer(
resolvedPath.Path,
itemContainerContext);
if (itemContainerContext.HasErrors())
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
itemContainerContext.ThrowFirstErrorOrDoNothing();
}
}
catch (NotSupportedException)
{
if (currentPath.Length == 0)
{
// Treat this as a container because providers that only
// support the ContainerCmdletProvider interface are really
// containers at their root.
isContainer = true;
}
}
finally
{
itemContainerContext.RemoveStopReferral();
}
if (isContainer)
{
if (foundContainer)
{
// The path resolved to more than one container
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
throw
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.PathResolvedToMultiple,
originalPath);
}
else
{
// Set the path to use
path = currentPath;
// Mark it as a container
pathIsContainer = true;
// Mark whether or not it was provider-qualified
pathIsProviderQualifiedPath = currentPathisProviderQualifiedPath;
// Mark that we have already found one container. Finding additional
// should be an error
foundContainer = true;
}
}
}
if (pathIsContainer)
{
// Remove the root slash since it is implied that the
// current working directory is relative to the root.
if (!LocationGlobber.IsProviderDirectPath(path) &&
path.StartsWith(StringLiterals.DefaultPathSeparator) &&
!pathIsProviderQualifiedPath)
{
path = path.Substring(1);
}
s_tracer.WriteLine(
"New working path = {0}",
path);
CurrentDrive.CurrentLocation = path;
}
else
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
throw
new ItemNotFoundException(
originalPath,
"PathNotFound",
SessionStateStrings.PathNotFound);
}
// Now make sure the current drive is set in the provider's
// current working drive hashtable
ProvidersCurrentWorkingDrive[CurrentDrive.Provider] =
CurrentDrive;
// Set the $PWD variable to the new location
this.SetVariable(SpecialVariables.PWDVarPath, this.CurrentLocation, false, true, CommandOrigin.Internal);
// If an action has been defined for location changes, invoke it now.
if (PublicSessionState.InvokeCommand.LocationChangedAction != null)
{
var eventArgs = new LocationChangedEventArgs(PublicSessionState, current, CurrentLocation);
PublicSessionState.InvokeCommand.LocationChangedAction.Invoke(ExecutionContext.CurrentRunspace, eventArgs);
s_tracer.WriteLine("Invoked LocationChangedAction");
}
return(this.CurrentLocation);
}
} // SetLocation
/// <summary>
/// Changes the current working directory to the path specified
/// </summary>
///
/// <param name="path">
/// The path of the new current working directory
/// </param>
///
/// <param name="context">
/// The context the provider uses when performing the operation.
/// </param>
///
/// <returns>
/// The PathInfo object representing the path of the location
/// that was set.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="path"/> is null.
/// </exception>
///
/// <exception cref="ArgumentException">
/// If <paramref name="path"/> does not exist, is not a container, or
/// resolved to multiple containers.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If <paramref name="path"/> refers to a provider that does not exist.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If <paramref name="path"/> refers to a drive that does not exist.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider associated with <paramref name="path"/> threw an
/// exception.
/// </exception>
///
/// <exception cref="ItemNotFoundException">
/// If the <paramref name="path"/> could not be resolved.
/// </exception>
///
internal PathInfo SetLocation(string path, CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
string originalPath = path;
string driveName = null;
ProviderInfo provider = null;
string providerId = null;
PSDriveInfo previousWorkingDrive = CurrentDrive;
// First check to see if the path is a home path
if (LocationGlobber.IsHomePath(path))
{
path = Globber.GetHomeRelativePath(path);
}
if (LocationGlobber.IsProviderDirectPath(path))
{
// The path is a provider-direct path so use the current
// provider and its hidden drive but don't modify the path
// at all.
provider = CurrentLocation.Provider;
CurrentDrive = provider.HiddenDrive;
}
else if (LocationGlobber.IsProviderQualifiedPath(path, out providerId))
{
provider = GetSingleProvider(providerId);
CurrentDrive = provider.HiddenDrive;
}
else
{
// See if the path is a relative or absolute
// path.
if (Globber.IsAbsolutePath(path, out driveName))
{
// Since the path is an absolute path
// we need to change the current working
// drive
PSDriveInfo newWorkingDrive = GetDrive(driveName);
CurrentDrive = newWorkingDrive;
// Now that the current working drive is set,
// process the rest of the path as a relative path.
}
}
if (context == null)
{
context = new CmdletProviderContext(this.ExecutionContext);
}
if (CurrentDrive != null)
{
context.Drive = CurrentDrive;
}
CmdletProvider providerInstance = null;
Collection <PathInfo> workingPath = null;
try
{
workingPath =
Globber.GetGlobbedMonadPathsFromMonadPath(
path,
false,
context,
out providerInstance);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception) // Catch-all OK, 3rd party callout
{
// Reset the drive to the previous drive and
// then rethrow the error
CurrentDrive = previousWorkingDrive;
throw;
}
if (workingPath.Count == 0)
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
throw
new ItemNotFoundException(
path,
"PathNotFound",
SessionStateStrings.PathNotFound);
}
// We allow globbing the location as long as it only resolves a single container.
bool foundContainer = false;
bool pathIsContainer = false;
bool pathIsProviderQualifiedPath = false;
bool currentPathisProviderQualifiedPath = false;
for (int index = 0; index < workingPath.Count; ++index)
{
CmdletProviderContext normalizePathContext =
new CmdletProviderContext(context);
PathInfo resolvedPath = workingPath[index];
string currentPath = path;
try
{
string providerName = null;
currentPathisProviderQualifiedPath = LocationGlobber.IsProviderQualifiedPath(resolvedPath.Path, out providerName);
if (currentPathisProviderQualifiedPath)
{
// The path should be the provider-qualified path without the provider ID
// or ::
string providerInternalPath = LocationGlobber.RemoveProviderQualifier(resolvedPath.Path);
try
{
currentPath = NormalizeRelativePath(GetSingleProvider(providerName), providerInternalPath, String.Empty, normalizePathContext);
}
catch (NotSupportedException)
{
// Since the provider does not support normalizing the path, just
// use the path we currently have.
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception) // Catch-all OK, 3rd party callout
{
// Reset the drive to the previous drive and
// then rethrow the error
CurrentDrive = previousWorkingDrive;
throw;
}
}
else
{
try
{
currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext);
}
catch (NotSupportedException)
{
// Since the provider does not support normalizing the path, just
// use the path we currently have.
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception) // Catch-all OK, 3rd party callout
{
// Reset the drive to the previous drive and
// then rethrow the error
CurrentDrive = previousWorkingDrive;
throw;
}
}
// Now see if there was errors while normalizing the path
if (normalizePathContext.HasErrors())
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
normalizePathContext.ThrowFirstErrorOrDoNothing();
}
}
finally
{
normalizePathContext.RemoveStopReferral();
}
// Check to see if the path is a container
bool isContainer = false;
CmdletProviderContext itemContainerContext =
new CmdletProviderContext(context);
itemContainerContext.SuppressWildcardExpansion = true;
try
{
isContainer =
IsItemContainer(
resolvedPath.Path,
itemContainerContext);
if (itemContainerContext.HasErrors())
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
itemContainerContext.ThrowFirstErrorOrDoNothing();
}
}
catch (NotSupportedException)
{
if (currentPath.Length == 0)
{
// Treat this as a container because providers that only
// support the ContainerCmdletProvider interface are really
// containers at their root.
isContainer = true;
}
}
finally
{
itemContainerContext.RemoveStopReferral();
}
if (isContainer)
{
if (foundContainer)
{
// The path resolved to more than one container
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
throw
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.PathResolvedToMultiple,
originalPath);
}
else
{
// Set the path to use
path = currentPath;
// Mark it as a container
pathIsContainer = true;
// Mark whether or not it was provider-qualified
pathIsProviderQualifiedPath = currentPathisProviderQualifiedPath;
// Mark that we have already found one container. Finding additional
// should be an error
foundContainer = true;
}
}
}
if (pathIsContainer)
{
// Remove the root slash since it is implied that the
// current working directory is relative to the root.
if (!LocationGlobber.IsProviderDirectPath(path) &&
path.StartsWith(StringLiterals.DefaultPathSeparatorString, StringComparison.CurrentCulture) &&
!pathIsProviderQualifiedPath)
{
path = path.Substring(1);
}
s_tracer.WriteLine(
"New working path = {0}",
path);
CurrentDrive.CurrentLocation = path;
}
else
{
// Set the current working drive back to the previous
// one in case it was changed.
CurrentDrive = previousWorkingDrive;
throw
new ItemNotFoundException(
originalPath,
"PathNotFound",
SessionStateStrings.PathNotFound);
}
// Now make sure the current drive is set in the provider's
// current working drive hashtable
ProvidersCurrentWorkingDrive[CurrentDrive.Provider] =
CurrentDrive;
// Set the $PWD variable to the new location
this.SetVariable(SpecialVariables.PWDVarPath, this.CurrentLocation, false, true, CommandOrigin.Internal);
return(this.CurrentLocation);
} // SetLocation
