cnping | Minimal Graphical IPV4 Ping Tool | HTTP library

You can "trick" curl to keep the connection open. For example like this:

1. Fire up nc to listen to a local port, say 8080 (nc -l -p 8080 on some versions of nc)
2. Run curl to get the resource you want, then add "localhost:8080" as a second URL on the same command line

This will make curl hold the first connection in its pool when it gets the second URL, and you make that second transfer just hang "indefinitely" which will make curl just leave the first connection open and alive until you control-c that or your nc process.

When a literal IPv6 address is used in a URL, it should be surrounded by square brackets (as per RFC 2732) so the colons in the literal address aren't misinterpreted as some kind of port designation.

When a literal IPv6 address is resolved using the C library function getaddrinfo (or the equivalent Haskell function getAddrInfo), these functions are not required to handle these extra square brackets, and at least on Linux they don't.

Therefore, it's the responsibility of the HTTP client library to remove the square brackets from the hostname extracted from the URL before resolving the literal IPv6 address using getaddrinfo, and the http-client package doesn't do this, at least as of version 0.7.10. So, this is a bug, and I can see you've appropriately filed a bug report.

Unfortunately, I don't see an easy way to work around the issue. You can manipulate the Request after parsing to remove the square brackets from the host field, like so:

No you do not need to encrypt the payload. SSL will do that for you. The payload would be secure between the client and the server.

Devtools can be only opened on the local instance of chrome client. Dev Tools only starts capturing data when it is open and if a request is made. Cannot be used in man-in-the-middle attack.

Sends exactly the bytes you specify in the body of the HTTP request. With a default Content-type of application/x-www-form-urlencoded. libcurl will not add or encode the data in any way for you.

With the curl command line tool, you do this with -d.

Makes libcurl send a "multipart formpost". That is a data stream using a format that allows the sender to send multiple "parts" of data to the server, each part being properly separated and identified. Each part has a name, content and its own set of headers. When an HTTP client "uploads a file", this is almost always done using multipart formposts.

Multipart formpost is structured data in the request body and this option helps you produce and send that format. An application can also produce that format by themselves should they prefer that and provide it with CURLOPT_POSTFIELDS or even using the callback CURLOPT_READFUNCTION.

With the curl command line tool, you do this with -F.

https://everything.curl.dev/libcurl-http/upload

I've been working on something similar recently and would suggest you try using the kovan network and the oracle that chainlink has there. Even more specifically, I think it would be a good idea to confirm you can get it working using the api, oracle, and jobid listed in the example on that page you are following... here:

https://docs.chain.link/docs/advanced-tutorial/#contract-example

Once you get that example working, then you can modify it for your usage. The jobid in that tutorial is for returning a (multiplied) uint256... which, for your API, I think is not what you want as you are wanting bytes32 it sounds like... so when you try to use it with your API that returns bytes32 the jobid would be: 7401f318127148a894c00c292e486ffd as seen here:

https://docs.chain.link/docs/decentralized-oracles-ethereum-mainnet/

Another thing that might be your issue, is your api. You say you control what it returns... I think it might have to return a response in bytes format, like Patrick says in his response (and his comments on his response) here:

Get a string from any API using Chainlink Large Response Example

Hope this is helpful. If you cannot get the example in the chainlink docs to work, let me know.

To mimic the python code you should use string interpolation:

Near as I can tell, there's no video player (for web) that supports RTSP or even HLS right now. Even the official video_player package from the flutter dev team doesn't seem to support that on web, yet. I can offer a workaround though....

If you implement a decent webrtc package and a media server, you can bypass the need to receive RTSP directly on your client. I've been using the flutter_webrtc package for a while now via the livekit_client package. Livekit has a SFU that could be used to proxy RTSP streams for communication to WebRTC enabled clients. I've seen a lot of people use ant media server for that sort of thing as well, and I'm pretty sure you can use the community edition of Ant for free.

People tend to use media servers for aggregating video streams so that instead of 1 client subscribing to 15 streams from various sources, instead a media server somewhere with a very good Internet connection and decent hardware subscribes to those streams and then generates a new video stream (or streams) such that your phone, or tablet, or laptop client somewhere on a 4G network, only has to receive (a) WebRTC stream(s) that can be optimized on the server in various ways.

EDIT: I had another thought, I don't know if this would work very well, but you could dynamically generate an HTML page inside an IFrame and use HTMLElementView. This would let you use a JavaScript/HTML5 video player to play your RTSP stream, however it comes with a heavy cost and you'd want to do a platform check to make sure you're running on web before using it.

I use dynamic HTTP requests inside component methods (e.g. when submitting a form via a POST request)? Does that even work in static sites?

The short answer to this question is that yes, it does work. In fact you can have http requests in any life cycle hooks or methods in your code, and they all work fine with static mode too.

Static site generation and ssr mode in Nuxt.js are tools to help you with SEO issues and I will explain the difference with an example.

Imagine you have a blog post page at a url like coolsite.com/blogs with some posts that are coming from a database.

SPA

In this mode, when a user visits the said URL server basically responds with a .js file, then in the client this .js file will be rendered. A Vue instance gets created and when the app reaches the code for the get posts request for example in the created hook, it makes an API call, gets the result and renders the posts to the DOM.

This is not cool for SEO since at the first app load there isn't any content and all search engine web crawlers are better at understanding content as html rather than js.

SSR

In this mode if you use the asyncData hook, when the user requests for the said URL, the server runs the code in the asyncData hook in which you should have your API call for the blog posts. It gets the result, renders it as an html page and sends that back to the user with the content already inside it (the Vue instance still gets created in the client). There is no need for any further request from client to server. Of course you still can have api calls in other methods or hooks.

The drawback here is that you need a certain way for deployment for this to work since the code must run on the server. For example you need node.js web hosting to run your app on the server.

STATIC

This mode is actually a compromise between the last two. It means you can have static web hosting but still make your app better for SEO.

The way it works is simple. You use asyncData again but here, when you are generating your app in your local machine it runs the code inside asyncData, gets the posts, and then renders the proper html for each of your app routes. So when you deploy and the user requests that URL, she/he will get a rendered page just like the one in SSR mode.

But the drawback here is that if you add a post to your database, you need to generate your app in your local machine, and update the required file(s) on your server with newly generated files in order for the user to get the latest content.

Apart from this, any other API call will work just fine since the code required for this is already shipped to the client.

Side note: I used asyncData in my example since this is the hook you should use in page level but fetch is also a Nuxt.js hook that works more or less the same for the component level.