routines | golang go routine management | SQL Database library

Failed to construct transformer: Error: error:0308010C:digital envelope routines::unsupported

The simplest and easiest solution to solve the above error is to downgrade Node.js to v14.18.1. And then just delete folder node_modules and try to rebuild your project and your error must be solved.

You should check the specifications of the device that is laggy and monitor RAM and CPU usage of the device, before, after and during your app runtime, speatially the RAM usage, maybe Android 30 is putting too much pressure on device and that is causing the issue.

In General the issue that are seen on some devices and not on another are caused ether by the difference between Android Versions and their resource handling methods or bottleneck between Hardware and Software on same OS version on different devices.

You can monitor device resource usage ether by Android Studio's own resource monitor tool "Android Profiler" or third party Resource Monitoring Apps found on Google Play.

If there is a process or function in your App that causing the resource leak you can fix it easily by detecting it from android profiler but if the issue is caused by OS Resource handling or Hardware and Software bottleneck you should skip that device.

Unfortunately I can't provide you with a fix, but I've found a workaround for that exact same problem (company-hosted bitbucket resulting in exact same error). I also don't know exactly why the problem occurs, but my best guess would be that the libressl library shipped with Monterey has some sort of problem with specific (?TLSv1.3) certs. This guess is because the brew-installed openssl v1.1 and v3 don't throw that error when executed with /opt/homebrew/opt/openssl/bin/openssl s_client -connect ...:443

To get around that error, I've built git from source built against different openssl and curl implementations:

1. install autoconf, openssl and curl with brew (I think you can select the openssl lib you like, i.e. v1.1 or v3, I chose v3)
2. clone git version you like, i.e. git clone --branch v2.33.1 https://github.com/git/git.git
3. cd git
4. make configure (that is why autoconf is needed)
5. execute LDFLAGS="-L/opt/homebrew/opt/openssl@3/lib -L/opt/homebrew/opt/curl/lib" CPPFLAGS="-I/opt/homebrew/opt/openssl@3/include -I/opt/homebrew/opt/curl/include" ./configure --prefix=$HOME/git (here LDFLAGS and CPPFLAGS include the libs git will be built against, the right flags are emitted by brew on install success of curl and openssl; --prefix is the install directory of git, defaults to /usr/local but can be changed)
6. make install
7. ensure to add the install directory's subfolder /bin to the front of your $PATH to "override" the default git shipped by Monterey
8. restart terminal
9. check that git version shows the new version

This should help for now, but as I already said, this is only a workaround, hopefully Apple fixes their libressl fork ASAP.

Ran into the same issue with Node.js 17.0.0. To solve it, I downgraded to version 14.18.1, deleted node_modules and reinstalled.

Your key seems to be a PEM encoded public key in X.509/SPKI format. However, the line breaks are missing. These are to be set so that header and footer are each on a single line. In the body there is a line break after every 64 characters.

A correctly formatted PEM key can be processed directly by createPublicKey(). The key will be accepted even if the line breaks in the body are missing, but header and footer must be in different lines, otherwise the posted error message will be displayed: error:0909006C:PEM routines:get_name:no start line.

Example:

I found this solution https://github.com/webpack/webpack/issues/14532

1. if using bash just run NODE_OPTIONS=--openssl-legacy-provider before any command

2. adding NODE_OPTIONS=--openssl-legacy-provider to package.json

Gatsby must be using an algorithm or key size which is no longer allowed by default with OpenSSL 3.0.

UPDATE ⚠️

This is most likely a webpack issue - https://github.com/webpack/webpack/issues/14532

They have since released a fix in version 5.61.0 - https://github.com/webpack/webpack/releases/tag/v5.61.0 - so upgrading webpack should address the issue as well

A member of the webpack team has stated they do not plan to backport the fix to webpack 4, so if you are on webpack 4 you may need to look to upgrading to webpack 5 first.

From Node.js 17's announcement post:

If you hit an ERR_OSSL_EVP_UNSUPPORTED error in your application with Node.js 17, it’s likely that your application or a module you’re using is attempting to use an algorithm or key size which is no longer allowed by default with OpenSSL 3.0. A new command-line option, --openssl-legacy-provider, has been added to revert to the legacy provider as a temporary workaround for these tightened restrictions.

Running this on the terminal might look like:

For example, does it break the compiler's ability to use the base+offset indexing on some hardware platform somewhere, or confuse the optimizer, etc.

No. C language standard clearly define it:

From C11 Standard#6.5.6p8:

8 When an expression that has integer type is added to or subtracted from a pointer, the result has the type of the pointer operand. If the pointer operand points to an element of an array object, and the array is large enough, the result points to an element offset from the original element such that the difference of the subscripts of the resulting and original array elements equals the integer expression. In other words, if the expression P points to the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of the array object, provided they exist. ....

Just, in case, if you are not aware:

From C11 Standard#6.5.2.1p2, the definition of subscript operator:

The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))).

Your another question:

but I'm curious of there is any performance downside to using this technique frequently.

It boils down to question - There are two number a and b, out of these two operations - a + b and a - b, which operation is faster than other.

It's not the language that dictate time for operations like addition, subtraction etc., but it's the underlying processor. If you are really interested in it, you have to dig down to the instruction set of underlying processor and compare the latency of respective instructions etc..

You might be sieving, but what about counting? And a upper limit, so one can compare? And OMP like primesieve?

You are stuck because you are not even counting or comparing, only with yourself.

I made a segmented sieve just with a 30Kb char array. At 2 billion, it takes quite exactly 3 times as long as primesieve, and works with OMP. So all your bit mapping and unrolling is not measurable.