rpc | DO NOT use it in PRODUCTION

I used systemd, it allows me to set any environment variable on service start.

1. place the executable jar and the application.properties in a folder, like /opt/ or /home//
2. sudo nano /etc/systemd/system/.service
3. Content:

Counter is not a valid account-id. Uppercase letters in accounts-id are not allowed). You need to pass the proper account-id.

I would expected your account-id to be something of the form takahashi.testnet or dev-1623565709996-68004511819798 (if contract was deployed using near dev-deploy command).

This is how you can deploy to testnet using dev-deploy, and call view function using near-cli:

After seeing whole log line entry

Can I try to read if it no data available?

Yep, and it's going to be case more often than not. Read() will do nothing until data is available, and only then put its passed tag into the completion queue. (see below for details)

Is it blocking call?

Nope. Read() and Write() return immediately. However, you can only have one of each in flight at any given moment. If you try to send a second one before the previous has completed, it (the second one) will fail.

What is the proper way to async reading?

Each time a Read() is done, start a new one. For that, you need to be able to tell when a Read() is done. This is where tags come in!

When you call Read(&msg, tag), or Write(request, tag),you are telling grpc to put tag in the completion queue associated with that responder once that operation has completed. grpc doesn't care what the tag is, it just hands it off.

So the general strategy you will want to go for is:

• As soon as you are ready to start receiving messages:
  • call responder->Read() once with some tag that you will recognize as a "read done".
• Whenever cq_.Next() gives you back that tag, and ok == true:
  • consume the message
  • Queue up a new responder->Read() with that same tag.

Obviously, you'll also want to do something similar for your calls to Write().

But since you still want to be able to lookup the handler instance from a given tag, you'll need a way to pack a reference to the handler as well as information about which operation is being finished in a single tag.

Lookup the handler instance from a given tag? Why?

The true raison d'être of completion queues is unfortunately not evident from the examples. They allow multiple asynchronous rpcs to share the same thread. Unless your application only ever makes a single rpc call, the handling thread should not be associated with a specific responder. Instead, that thread should be a general-purpose worker that dispatches events to the correct handler based on the content of the tag.

The official examples tend to do that by using pointer to the handler object as the tag. That works when there's a specific sequence of events to expect since you can easily predict what a handler is reacting to. You often can't do that with async bidirectional streams, since any given completion event could be a Read() or a Write() finishing.

Here's a general outline of what I personally consider to be a clean way to go about all that:

Notebooks are based on Compute Instances. If you activate Notebooks API and create a new Notebook from Notebooks UI, you will see the corresponding VM in both Notebooks UI and Compute Engine page. If you want to disable Notebooks API you need to:

1. Backup Noteboks information
2. Delete Notebooks from Notebooks UI page. This will delete Notebooks records and VMs
3. Deactivate Notebooks API
4. Go to Notebooks UI and create back the Notebooks (this will use Compute Engine API instead) We use Compute Engine API when Notebooks API is not enabled. This is currently discouraged but you have this option. (You will miss features such as auto-upgrade, health endpoint, instance monitoring)

Curious: Why you want to Disable Notebooks API?

Update

You have created two daemon processes. They will terminate when all non-daemon processes have terminated, which in this case is the main process, which terminates immediately after creating the daemon processes. You are lucky that even one of the processes has a chance to produce output, but why take chances? Do not use dameon processes. Instead:

** UPDATE **

The VaultCustomQueryCriteria by default set the stateStatus = UNCONSUMED in its constructor:

The problem is (most probably) caused by the last semi colon in your DDL script. It seems that the --ddl-file option accepts scripts with multiple DDL statements that may be separated by semi colons (;), but the last statement should not be terminated by a semi colon. Doing so will cause gcloud to try to parse another DDL statement after the last, only to determine that there is none, and thereby throwing an Unexpected end of file error.

So TLDR: Remove the last semi colon in your script and it should work.

Build args were only recently added to compose-cli. Most likely that change hasn't reached the version of docker compose you're running. You can use docker-compose build (with a -) until this feature reaches your install.