How do I make powershell script transverse zip files and report based off select-string -pattern

Question

I have the following that is working but I need to also have the ability to read the contents of compressed file (zip)

function Search-Files {
param ([string[]]$Servers, [string]$SearchPath, [string]$SearchItem, [string[]]$LogName)

ForEach ($Server in $Servers) {
    if ($LogName -eq $null) {
        dir -Path \\$server\$SearchPath -Recurse -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue | Select-String -pattern $SearchItem -ErrorAction SilentlyContinue -WarningAction SilentlyContinue | Select-Object Filename, Path, Matches, LineNumber
    }
    Else {
        dir -Path \\$server\$SearchPath -Recurse -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue | ? {$_.Name -match $LogName} | Select-String -pattern $SearchItem -ErrorAction SilentlyContinue -WarningAction SilentlyContinue | Select-Object Filename, Path, Matches, LineNumber
    }
  }
}

Currently I am getting the following out put displayed which is what I would like to do for zip files as well

ip.ininlog \CO200197L\C$\Temp\Test\Test\ip\ip.ininlog {3030872954} 136594

I have found the following just not sure how to proceed to get them implemented

Grep File in Zip

List File in Zip

I need the ability to transverse all zip files that are store in a directory

Sample of Directory Structure

 2014-07-01 - root
     zip.zip
     zip_1.zip
     zip_2.zip
     etc

Answer 1

In case you have NET 4.5 framework installed, you can use 4.5's built-in ZIP support to extract files to a temporary path and run the selection on the temporary file. If no 4.5 is available, I recommend using SharpCompress (https://sharpcompress.codeplex.com/) which works in a similar way.

The following code snippet demonstrates extracting a ZIP archive into a temporary file, running the selection process from your script and the cleanup after the extraction. You can significantly simplify the code by extracting the entire ZIP file at once (just use ExtractToDirectory() on the archive) if it contains only the files you are seeking.

# import .NET 4.5 compression utilities
Add-Type -As System.IO.Compression.FileSystem;

# the input archive
$archivePath = "C:\sample.zip";

# open archive for reading
$archive = [System.IO.Compression.ZipFile]::OpenRead($archivePath);
try
{
    # enumerate all entries in the archive, which includes both files and directories
    foreach($archiveEntry in $archive.Entries)
    {
        # if the entry is not a directory (which ends with /)
        if($archiveEntry.FullName -notmatch '/$')
        {
            # get temporary file -- note that this will also create the file
            $tempFile = [System.IO.Path]::GetTempFileName();
            try
            {
                # extract to file system
                [System.IO.Compression.ZipFileExtensions]::ExtractToFile($archiveEntry, $tempFile, $true);

                # create PowerShell backslash-friendly path from ZIP path with forward slashes
                $windowsStyleArchiveEntryName = $archiveEntry.FullName.Replace('/', '\');
                # run selection
                Get-ChildItem $tempFile | Select-String -pattern "yourpattern" | Select-Object @{Name="Filename";Expression={$windowsStyleArchiveEntryName}}, @{Name="Path";Expression={Join-Path $archivePath (Split-Path $windowsStyleArchiveEntryName -Parent)}}, Matches, LineNumber
            }
            finally
            {
                Remove-Item $tempFile;
            }
        }
    }
}
finally
{
    # release archive object to prevent leaking resources
    $archive.Dispose();
}

If you have multiple ZIP files in the directory, you can enumerate them as follows (using your example script):

$zipArchives = Get-ChildItem -Path \\$server\$SearchPath -Recurse "*.zip";
foreach($zipArchive in $zipArchives)
{
   $archivePath = $zipArchive.FullName;
   ...
}

You can place the demo code in ... or move it to a PowerShell function.

Answer 2

Sometimes is not desirable to extract a zip entry as a file. Instead it may be preferable to work with the file in memory. Extracting a Zip entry containing XML or JSON text so it can be parsed in memory is an example.

Here is a technique that will allow you to do this. This example assumes there is a Zip entry with a name ending in .json and it is this file which is to be retrieved. Clearly the idea can be modified to handle different cases.

This code should work with version of the .NET Framework that includes the System.IO.Compression namespace.

try
{
    # import .NET 4.5 compression utilities
    Add-Type -As System.IO.Compression.FileSystem;

    # A variable to hold the recovered JSON content
    $json = $null

    $zip = [IO.Compression.ZipFile]::OpenRead($zipFileName)
    $zip.Entries | 
        Where-Object { $_.Name.EndsWith(".json") } | 
        ForEach-Object {

        # Use a MemoryStream to hold the inflated file content
        $memoryStream = New-Object System.IO.MemoryStream

        # Read the entry
        $file = $_.Open()

        # Copying inflates the entry content
        $file.CopyTo($memoryStream)

        # Make sure the entry is closed
        $file.Dispose()

        # After copying, the cursor will be at the end of the stream
        # so set the position to the beginning or there will be no output
        $memoryStream.Position = 0

        # Use a StreamReader because it allows the content to be
        # read as a string in one go
        $reader = New-Object System.IO.StreamReader($memoryStream)

        # Read the content as a string                       
        $json = $reader.ReadToEnd()

        # Close the reader and memory stream
        $reader.Dispose()
        $memoryStream.Dispose()
    }

    # Finally close the zip file.  This is necessary 
    # because the zip file does get closed automatically
    $zip.Dispose() 

    # Do something with the JSON in memory
    if ( $json -ne $null )
    {
        $objects = $json | ConvertFrom-Json
    }
}
catch
{
    # Report errors
}