http-cache | High performance Golang HTTP middleware for server-side | HTTP library

I think your project has some node to treat this warning as error which leads this issue.

In our side, it is just a nuget warning and will not preventing the installation of the package.

Please check on xxx.csproj, any imported targets or props files, Directory.Build.props or Directory.Build.props if you used.

Remove any node on those files:

The HTTP/2 specification in RFC 7540 says:

Once a client receives a PUSH_PROMISE frame and chooses to accept the pushed response, the client SHOULD NOT issue any requests for the promised response until after the promised stream has closed.

So it seems to be likely that the request will wait for the push response to be delivered, if the server does not take too long to start sending:

If the client determines, for any reason, that it does not wish to
receive the pushed response from the server or if the server takes
too long to begin sending the promised response, the client can send
a RST_STREAM frame, using either the CANCEL or REFUSED_STREAM code
and referencing the pushed stream's identifier.

Solution-local packages folders are no longer exist for .NET Core and Visual Studio 2017.

NuGet is now fully integrated into MSBuild:

Solution-local packages folders are no longer used – Packages are now resolved against the user’s cache at %userdata%.nuget, rather than a solution specific packages folder. This makes PackageReference perform faster and consume less disk space by using a shared folder of packages on your workstation.

NuGet 4.0+ uses at least two global package locations:

• User-specific: %userprofile%\.nuget\packages\
• Machine-wide: %ProgramFiles(x86)%\Microsoft SDKs\NuGetPackages\"

You can list all user-specific folders using the following console command:

I found the issue. Withing the app Gradle file. The following snippet

It seems that your namespace is define improperly. In your composer.json, class UserController under the namespace Controllers.

you should define a namespace at the top of your UserController.php:

Another possibility is to use Electron's commandLine.appendSwitch () in the main process on the app object, right before anything gets executed:

Your second approach has no chance of working. The firebase.json file is using by Firebase Hosting and completely unrelated to Cloud Firestore.

Your first approach could work, although you didn't include the code that actually determines when you attach the onSnapshot listener. But as you discovered, attaching the listener at most twice a day means that you only get updates at most twice a day, and that you may be serving stale data in the meantime.

It sounds like you'll have to choose between serving fresh data, and reducing server calls. This is a fairly common trade-off.

There are a few other ways to reduce the number of document reads needed to server the latest data though:

1. Include a timestamp when the data was updated in each document, and then use a query to only request new data. You'll keep the timestamp of when you last requested/got data in local storage, and use that in the query each time.
2. Aggregate the data for recent updates into one or a few documents, so that you have to read fewer documents.

I assume you are asking about which headers should you configure to be sent from your server, and by "client" you mean "modern web browser"? Then the quoted question/answer is correct, so:

1. Yes, you should set both, but max-age=0 is enough, (must-revalidate is the default behavior)
2. Yes, correct, the response would be served from local cache until max-age expires, after that it would be revalidated (once), then again served from local cache and so on
3. It is kind of undefined, and differs between browsers and the way you send request (clicking link from html, hitting reload button, typing directly in address bar and hitting enter). Generally, response should not be served directly from cache but it could either just be revalidated or full response can be requested from server.
4. Revalidate means that client asks server to send the content only if it has been changed since it was last retrieved. In order for this to work, in response to initial request server will send either one or both of:
   • Etag header (which contains hashed value of the content), which client will cache and send back in revalidation request as If-None-Match header, so server can compare clients cached Etag value with the current Etag on server side. If the value did not change, server will respond with 304 Not Modified (and empty body), and if the value changed, server will respond with 200 and full (new) content
   • Last-Modified (which contains timestamp of the last content modification), and client will send that in revalidation request in If-Modified-Since header, which will be used on server side to detirmine the response (304 or 200)

Cache-control: no-cache might achieve the same effect in most of the (simple) cases. The situation where things get complicated is when there are intermediate caches between client and the server, or when you want to tweak client behavior (for example when sending AJAX requests) and that is when most of the caching directives come into use

Varnish Laradock is using proxy

You can configure your .env variables for varnish.

and run `docker-compose up proxy.