Portable check for library

Question

A project I am trying to compile has this command:

cc -xc++ -o/dev/null -lc++ -shared

However I am using PowerShell, which has no notion of /dev/null:

PS C:\> cc -xc++ -o/dev/null -lc++ -shared
C:/msys2/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/10.2.0/../../../../
x86_64-w64-mingw32/bin/ld.exe: cannot open output file /dev/null.exe: No such
file or directory

I tried using -o$null, but it just creates a file $null.exe. I also tried this:

PS C:\> cc -xc++ -o $null -lc++ -shared
cc.exe: fatal error: no input files

Is PowerShell able to handle this use case? Alternatively, it seems the purpose of the test is to just check if libc++ exists. Is another way available to do that?

Answer 1

There are few points that you need to look into.

Usually in production code, we need to have timeouts. If you are making an ajax call to the backend API, there will be a timeout associated with that api call. Suppose if the timeout is more than 2 mins, then it will send you a 504 Gateway timeout error.

To overcome this and to implement the functionality which you want, you can have any DB(lets consider SQL server). In your SQL server, make a table: Process_Table With schema: Process_id( Will store the process id/name ) Percentage( Will store the percentage ) At_step ( Parsing, Mapping, Sending to DB etc)

Using Javascript(Or any framework of your choice), use setInterval(), to make check_process() api calls. For check_proceess, you can pass in the process_id, and check against the db. For interval, you can set it to 5 seconds. So that every 5 seconds the call is made.

You can read the response of those API calls and do your processing.

Answer 2

An HTTP request consists of a request and a response. There's no direct way to get status updates beyond the onprogress event which would let you see how much data has been transferred. This is useful for determining how much of the data has been sent to the server, but not so much for how far the server has got with working with that data.

You could store progress in a database and poll a webservice to read the most recent status.

You could also have the server push updates to the client using Websockets for bi-directional communication.

A rough outline for such a system might look like:

1. Open a Websocket
2. Send files with Ajax
3. Get server generated ID back in HTTP response
4. Pay attention to messages coming over the Websocket that mention that ID

You could also look at doing the whole thing over Websockets (i.e. upload the files that way too). A quick Google search turns up this library for uploading files to a Websocket service hosted on Node.js.