FileInfo | Basic file metadata gathering script

I would change the order of the problem.

1. Create a list of all files (into memory)
2. Perform the search over the memory list

Then, you can use a Parallel Foreach over the memory array and your disk usage is limited to the initial search.

So, I was wrong posting the last answer. I found out, the libc binary contained something like __xstat and I called it.

Wrong! As the name would suggest, it was a kind of a private function, something intended to be an implementation detail, not a part of the API.

So I found another function with a normal name: statx. It does exactly what I need, it is well(-ish) documented here:

https://man7.org/linux/man-pages/man2/statx.2.html

Here's the structure and values: https://code.woboq.org/qt5/include/bits/statx.h.html https://code.woboq.org/userspace/glibc/io/fcntl.h.html

TL;DR - it works.

I figured out that -100 (AT_FDCWD) passed as dirfd parameter makes relative paths relative to the current working directory.

I also figured out that passing zeros as flags works (as equivalent to AT_STATX_SYNC_AS_STAT), and the function returns what it should for a regular local filesystem.

So here's the code:

You are passing the props for FileDetailScreen using the navigation route param props. If you have a screen

There are many ways you can do this, here is one example using recursion. I have stripped your function out of it's original code just to show you how the logic works.

1. Add a -Retries parameter to the function, leaving it's default value to 2 for testing. This value can be changed later and also when calling the function -Retries X can be used if more retries are needed later on the road.
2. If the try block fails, subtract 1 from the counter in the catch block.
3. If $Retries is not yet 0 (-not $PSBoundParameters.Retries), make the function call itself passing the same arguments.
4. If $Retries has reached 0, send the email and end the function.

It's important to note that the Webclient class uses the RETR command to download an FTP resource. For an HTTP resource, the GET method is used. That means if you provide a URL that doesn't contains the correct parameters to a downloadable file, you gonna end up with some exceptions that are not handled because Webclient was replaced with System.Net.Http.HttpClient, that I recommend you use instead.

Below you can see a exemple of how the Webclient works, on your case you are getting "useless error" because you are on a async method. I would suggest to use the normal method like below to debug and get the correct exception.

GridFS is a specification for storing and retrieving files that exceed the BSON document size limit of 16 MB. GridFS is a convention implemented by all MongoDB drivers that stores binary data across many smaller documents. The binaries are split into the chunks and then the chunks are stored in collections created by GridFS.

Having said that, given the presented use cases i would highly recommend using media server for storage as given the application landscape, that makes a more economical, viable and scalable solution.

Having said that, I would generally, avoid putting BLOBs in the database if there are other storage options that cost less as using a database as BLOB store is generally not a cost optimised solution. Sure, there are valid reasons for storing blobs in the database, but given the application’s use case (it being media intensive), use the media server for file storage, and databases for data structures.

In such cases, It is often easy to get "cost unoptimized" with time. Plus the database size would grow exponentially with time, bringing it's own challenges with RAM (WiredTiger Cache) management.

All in all - if it was me - I would use media storage for BLOB intensive applications than relying on databases.

Although PowerShell is more or less a "real .NET language", it does extend the common type system with an array of behaviors that sometimes conflict with what you know about .NET's type system behavior from languages like C# or VB.NET.

This additional type system layer bolted on top of the CLR is aptly named the Extended Type System (ETS), and it's directly responsible for making argument conversion "just work" the way you've observed.

When the PowerShell runtime reaches a method invocation statement like $util.GetFirstLine("C:\temp\random-log.txt"), it has to pick an appropriate overload, just like the C# compiler does.

The first step is to identity overloads for which the number of arguments passed can cover all mandatory parameters of the given overload signature. In your case, only 1 such signature can be resolved at this step, so PowerShell now has two pieces of the puzzle:

• A method stub with the signature string GetFirstLine(FileInfo fileInfo)
• An argument value of type [string]

At this point, the C# compiler would give up and report CS1503: Argument 1: cannot convert from 'string' to 'System.IO.FileInfo'.

PowerShell, on the other hand, is designed to be helpful in the hands of system administrators and operators - people who might not put too much thought into data structure design, but who are chiefly concerned with string representations of data (after all, this is what bash, cmd, etc. taught them to use).

To meaningfully convert from a string (or any other non-compliant argument type) at just the right time, ETS comes with a number of facilities and hooks for implicit type conversion that the runtime then attempts, one by one, until it either finds a valid conversion mechanism, or fails (at which point the method invocation fails too):

• Built-in converters

  • These take priority to handle the most common edge cases, like null-conversions, "truthy/falsy"-to-real-[bool] conversions, stringification of scalars, etc. - without these, PowerShell would be a pain in the ass to work with interactively.
  • Example:
    • These flow control statements behave exactly like you'd expect thanks to built-in conversions: if($null){ <# unreachable #> }, do{ Stop-Process chrome }while(Get-Process chome)

• Custom type converters

  • These are concrete type converter implementations registered to one or more target types - this can be useful for modifying the binding behavior of complex types you've brought with you into the runtime.
  • Example:
    • The RSAT ActiveDirectory module uses type adapters to interchange between the different data types modeling specific directory object classes - allowing you to seamlessly pipe output from Get-ADComputer (very specific output type) to Get-ADObject (generalized output type) and vice versa.

• Parse converters

  • If no appropriate built-in or custom type converter can be found, PowerShell will attempt to resolve a Parse() method with the appropriate return type on the target type.
  • Example:
    • The cast operation [timespan]'1.02:15:25' can succeed this way.

• Constructor-based conversions

  • If none of the above works, PowerShell will attempt to resolve a constructor that can be invoked with a single parameter argument of the source type given.
  • This is what happens in your case - PowerShell effectively excutes $util.GetFirstLine([System.IO.FileInfo]::new("C:\temp\random-log.txt")) for you

• CTS conversions

  • Finally, if all of ETS' conversation attempts fail, it falls back to resolving implicit (and eventually explicit) conversions defined by the types themselves.
  • Example:
    • This conversion succeeds because the [DateTimeOffset] type has an implicit conversion operator for [DateTime]: (Get-Date) -as [DateTimeOffset]

The concrete type converters mentioned above will automatically be respected by ETS if they've either been included in a type data file (see about_Types.ps1xml), or if the target type is public and the source definition was decorated with a [TypeConverter()] attribute.

Additionally, you can register new type conversion primitives at runtime with the Update-TypeData cmdlet.

Of course the madness doesn't stop there, there are also additional facilities specifically for converting/transform command arguments, but that's beyond the scope of this question :)

What can explain your script validation failing is that you're not quoting the path with spaces, an easy way of testing this using Write-Host $_ on your ValidateScript attribute:

• Given script.ps1:

Think you're missing a using line: