public void ClearContent(string path)
{
StreamContentReaderWriter stream = null;
ZipFileItemInfo archiveFile = GetItemHelper(path);
archiveFile.ClearContent();
}
/// <summary>
/// Removes the specified file or directory.
/// </summary>
/// <param name="path">
/// The full path to the file or directory to be removed.
/// </param>
/// <param name="recurse">
/// Specifies if the operation should also remove child items.
/// </param>
/// <exception cref="System.ArgumentException">
/// path is null or empty.
/// </exception>
protected override void RemoveItem(string path, bool recurse)
{
if (string.IsNullOrEmpty(path))
{
throw PSTraceSource.NewArgumentException("path");
}
path = NormalizePath(path);
if (!ItemExists(path))
{
throw new Exception("Item not exists");
}
ZipFileItemInfo ArchiveItem = GetItemHelper(path);
ArchiveItem.Delete();
}
/// <summary>
/// Gets the item at the specified path.
/// </summary>
/// <param name="path">
/// A fully qualified path representing a file or directory in the
/// file system.
/// </param>
/// <returns>
/// Nothing. FileInfo and DirectoryInfo objects are written to the
/// context's pipeline.
/// </returns>
/// <exception cref="System.ArgumentException">
/// path is null or empty.
/// </exception>
protected override void GetItem(string path)
{
path = NormalizePath(path);
// Validate the argument
bool isContainer = false;
if (string.IsNullOrEmpty(path))
{
// The parameter was null, throw an exception
throw PSTraceSource.NewArgumentException("path");
}
try
{
ZipFileItemInfo result = new ZipFileItemInfo(PSDriveInfo, path);
// FileSystemInfo result = GetFileSystemItem(path, ref isContainer, false);
if (result != null)
{
// Otherwise, return the item itself.
WriteItemObject(result, result.FullName, isContainer);
}
else
{
string error = StringUtil.Format(FileSystemProviderStrings.ItemNotFound, path);
Exception e = new IOException(error);
WriteError(new ErrorRecord(
e,
"ItemNotFound",
ErrorCategory.ObjectNotFound,
path));
}
}
catch (IOException ioError)
{
// IOException contains specific message about the error occured and so no need for errordetails.
ErrorRecord er = new ErrorRecord(ioError, "GetItemIOError", ErrorCategory.ReadError, path);
WriteError(er);
}
catch (UnauthorizedAccessException accessException)
{
WriteError(new ErrorRecord(accessException, "GetItemUnauthorizedAccessError", ErrorCategory.PermissionDenied, path));
}
}
/// <summary>
/// Creates a file or directory with the given path.
/// </summary>
/// <param name="path">
/// The path of the file or directory to create.
/// </param>
///<param name="type">
/// Specify "file" to create a file.
/// Specify "directory" or "container" to create a directory.
/// </param>
/// <param name="value">
/// If <paramref name="type" /> is "file" then this parameter becomes the content
/// of the file to be created.
/// </param>
/// <returns>
/// Nothing. The new DirectoryInfo or FileInfo object is
/// written to the context's pipeline.
/// </returns>
/// <exception cref="System.ArgumentException">
/// path is null or empty.
/// type is null or empty.
/// </exception>
protected override void NewItem(
string path,
string type,
object value)
{
//ItemType itemType = ItemType.Unknown;
// Verify parameters
if (string.IsNullOrEmpty(path))
{
throw PSTraceSource.NewArgumentException("path");
}
if (string.IsNullOrEmpty(type))
{
type = "file";
}
path = NormalizePath(path);
// if (Force)
// {
// if (!CreateIntermediateDirectories(path))
// {
// return;
// }
// }
if (ItemExists(path))
{
throw new Exception("File Exists");
}
if (type == "file")
{
ZipFileItemInfo newItem = NewItemHelper(path);
if (value != null)
{
using (StreamWriter writer = newItem.AppendText())
{
writer.Write(value.ToString());
writer.Flush();
writer.Dispose();
}
}
}
}
internal ZipFileItemInfo NewItemHelper(string path)
{
try {
using (ZipArchive zipArchive = ZipFile.Open(PSDriveInfo.Root, ZipArchiveMode.Update))
{
path = NormalizePath(path);
ZipArchiveEntry zipArchiveEntry = zipArchive.CreateEntry(path);
ZipFileItemInfo zipFileItemInfo = new ZipFileItemInfo(zipArchiveEntry, PSDriveInfo);
return(zipFileItemInfo);
}
}
catch (Exception e) {
throw e;
}
}
protected override void GetChildItems(string path, bool recurse)
{
path = NormalizePath(path);
if (String.IsNullOrEmpty(path))
{
path = "*";
}
// WriteWarning($"[TODO] GetChildItems(string path) '{path}'");
List <ZipFileItemInfo> results = ZipFileItemInfo.GetFileItemInfo(PSDriveInfo, path);
foreach (ZipFileItemInfo entry in results)
{
WriteItemObject(entry, entry.FullName, false);
}
}
/// <summary>
/// Determines if the specified path is syntactically and semantically valid.
/// An example path looks like this
/// C:\WINNT\Media\chimes.wav.
/// </summary>
/// <param name="path">
/// The fully qualified path to validate.
/// </param>
/// <returns>
/// True if the path is valid, false otherwise.
/// </returns>
protected override bool IsValidPath(string path)
{
// Path passed should be fully qualified path.
if (string.IsNullOrEmpty(path))
{
return(false);
}
Console.WriteLine($"IsValidPath('{path}')");
// Normalize the path
path = NormalizePath(path);
// path = EnsureDriveIsRooted(path);
// Make sure the path is either drive rooted or UNC Path
if (!IsAbsolutePath(path) && !Utils.PathIsUnc(path))
{
return(false);
}
// Exceptions should only deal with exceptional circumstances,
// but unfortunately, FileInfo offers no Try() methods that
// let us check if we _could_ open the file.
try
{
ZipFileItemInfo testFile = new ZipFileItemInfo(PSDriveInfo, path);
}
catch (Exception e)
{
if ((e is ArgumentNullException) ||
(e is ArgumentException) ||
(e is System.Security.SecurityException) ||
(e is UnauthorizedAccessException) ||
(e is PathTooLongException) ||
(e is NotSupportedException))
{
return(false);
}
else
{
throw;
}
}
return(false);
}
/// <summary>
/// Renames a file or directory.
/// </summary>
///
/// <param name="path">
/// The current full path to the file or directory.
/// </param>
///
/// <param name="newName">
/// The new full path to the file or directory.
/// </param>
///
/// <returns>
/// Nothing. The renamed DirectoryInfo or FileInfo object is
/// written to the context's pipeline.
/// </returns>
///
/// <exception cref="System.ArgumentException">
/// path is null or empty.
/// newName is null or empty
/// </exception>
protected override void RenameItem(string path, string newName)
{
// Check the parameters
if (String.IsNullOrEmpty(path))
{
throw PSTraceSource.NewArgumentException("path");
}
path = NormalizePath(path);
if (String.IsNullOrEmpty(newName))
{
throw PSTraceSource.NewArgumentException("newName");
}
newName = NormalizePath(newName);
// Clean up "newname" to fix some common usability problems:
// Rename .\foo.txt .\bar.txt
// Rename c:\temp\foo.txt c:\temp\bar.txt
if (newName.StartsWith(".\\", StringComparison.OrdinalIgnoreCase) ||
newName.StartsWith("./", StringComparison.OrdinalIgnoreCase))
{
newName = newName.Remove(0, 2);
}
//else if (String.Equals(Path.GetDirectoryName(path), Path.GetDirectoryName(newName), StringComparison.OrdinalIgnoreCase))
//{
// newName = Path.GetFileName(newName);
//}
// Check to see if the target specified exists.
if (ItemExists(newName))
{
throw PSTraceSource.NewArgumentException("newName", FileSystemProviderStrings.RenameError);
}
try
{
// Manually move this item since you cant have more than one stream open at a time.
ZipFileItemInfo file = new ZipFileItemInfo(PSDriveInfo, path);
ZipFileItemInfo result;
// Confirm the rename with the user
string action = FileSystemProviderStrings.RenameItemActionFile;
string resource = StringUtil.Format(FileSystemProviderStrings.RenameItemResourceFileTemplate, file.FullName, newName);
if (ShouldProcess(resource, action))
{
// Now move the file
file.MoveTo(newName);
result = file;
WriteItemObject(result, result.FullName, false);
}
}
catch (ArgumentException argException)
{
WriteError(new ErrorRecord(argException, "RenameItemArgumentError", ErrorCategory.InvalidArgument, path));
}
catch (IOException ioException)
{
//IOException contains specific message about the error occured and so no need for errordetails.
WriteError(new ErrorRecord(ioException, "RenameItemIOError", ErrorCategory.WriteError, path));
}
catch (UnauthorizedAccessException accessException)
{
WriteError(new ErrorRecord(accessException, "RenameItemUnauthorizedAccessError", ErrorCategory.PermissionDenied, path));
}
}
public ZipFileContentStream(ZipFileItemInfo archiveFileInfo, FileMode mode, string delimiter, Encoding encoding, bool usingByteEncoding, CmdletProvider provider, bool isRawStream)
: base(archiveFileInfo.Open(mode), delimiter, encoding, provider, isRawStream)
{
_provider = provider;
}
public ZipFileContentStream(ZipFileItemInfo archiveFileInfo, FileMode mode, Encoding encoding, bool usingByteEncoding, CmdletProvider provider, bool isRawStream, bool suppressNewline)
: base(archiveFileInfo.Open(mode), encoding, usingByteEncoding, provider, isRawStream, suppressNewline)
{
_provider = provider;
}
/// <summary>
/// Creates an instance of the FileSystemContentStream class, opens
/// the specified file for reading, and returns the IContentReader interface
/// to it.
/// </summary>
/// <param name="path">
/// The path of the file to be opened for reading.
/// </param>
/// <returns>
/// An IContentReader for the specified file.
/// </returns>
/// <exception cref="System.ArgumentException">
/// path is null or empty.
/// </exception>
public IContentReader GetContentReader(string path)
{
if (string.IsNullOrEmpty(path))
{
throw PSTraceSource.NewArgumentException("path");
}
path = NormalizePath(path);
// Defaults for the file read operation
string delimiter = "\n";
// Encoding encoding = Encoding.Default;
Encoding encoding = ClrFacade.GetDefaultEncoding();
bool streamTypeSpecified = false;
bool usingByteEncoding = false;
bool delimiterSpecified = false;
bool isRawStream = false;
// Get the dynamic parameters.
// They override the defaults specified above.
if (DynamicParameters != null)
{
StreamContentReaderDynamicParameters dynParams = DynamicParameters as StreamContentReaderDynamicParameters;
if (dynParams != null)
{
// -raw is not allowed when -first,-last or -wait is specified
// this call will validate that and throws.
ValidateParameters(dynParams.Raw);
isRawStream = dynParams.Raw;
// Get the delimiter
delimiterSpecified = dynParams.DelimiterSpecified;
if (delimiterSpecified)
{
delimiter = dynParams.Delimiter;
}
// Get the stream type
usingByteEncoding = dynParams.AsByteStream;
streamTypeSpecified = dynParams.WasStreamTypeSpecified;
if (usingByteEncoding && streamTypeSpecified)
{
WriteWarning(FileSystemProviderStrings.EncodingNotUsed);
}
if (streamTypeSpecified)
{
encoding = dynParams.Encoding;
}
}
}
StreamContentReaderWriter stream = null;
ZipFileItemInfo archiveFile = GetItemHelper(path);
//Archive.FileStream archiveStream = archiveFile.Open(FileMode.Append);
try
{
// Users can't both read as bytes, and specify a delimiter
if (delimiterSpecified)
{
if (usingByteEncoding)
{
Exception e =
new ArgumentException(FileSystemProviderStrings.DelimiterError, "delimiter");
WriteError(new ErrorRecord(
e,
"GetContentReaderArgumentError",
ErrorCategory.InvalidArgument,
path));
}
else
{
//Console.WriteLine("Get-Content : Delimiter");
stream = new ZipFileContentStream(archiveFile, FileMode.Append, delimiter, encoding, usingByteEncoding, this, isRawStream);
}
}
else
{
//Console.WriteLine("Get-Content : Default");
stream = new ZipFileContentStream(archiveFile, FileMode.Append, encoding, usingByteEncoding, this, isRawStream);
}
}
catch (PathTooLongException pathTooLong)
{
WriteError(new ErrorRecord(pathTooLong, "GetContentReaderPathTooLongError", ErrorCategory.InvalidArgument, path));
}
catch (FileNotFoundException fileNotFound)
{
WriteError(new ErrorRecord(fileNotFound, "GetContentReaderFileNotFoundError", ErrorCategory.ObjectNotFound, path));
}
catch (DirectoryNotFoundException directoryNotFound)
{
WriteError(new ErrorRecord(directoryNotFound, "GetContentReaderDirectoryNotFoundError", ErrorCategory.ObjectNotFound, path));
}
catch (ArgumentException argException)
{
WriteError(new ErrorRecord(argException, "GetContentReaderArgumentError", ErrorCategory.InvalidArgument, path));
}
catch (IOException ioException)
{
// IOException contains specific message about the error occured and so no need for errordetails.
WriteError(new ErrorRecord(ioException, "GetContentReaderIOError", ErrorCategory.ReadError, path));
}
catch (System.Security.SecurityException securityException)
{
WriteError(new ErrorRecord(securityException, "GetContentReaderSecurityError", ErrorCategory.PermissionDenied, path));
}
catch (UnauthorizedAccessException unauthorizedAccess)
{
WriteError(new ErrorRecord(unauthorizedAccess, "GetContentReaderUnauthorizedAccessError", ErrorCategory.PermissionDenied, path));
}
catch (Exception e)
{
WriteError(
new ErrorRecord(e, "Unhandled Error", ErrorCategory.InvalidArgument, path)
);
}
if (stream == null)
{
throw new Exception("Invalid stream");
}
return(stream);
}
