Committed | weekly todos and goals in Google Chrome

Try running these 2 scripts in two different tabs with app.snowflake.com:

Script 1:

What I can't understand is that sometimes I was able to switch the branch with uncommitted changes, and sometimes I wasn't.

Because there are currently common files between master and features: switching branches would mean overriding the current modification on those common files, which Git actively prevents.

If there are no common files (like new private files in feature, not yet added/committed), then you can switch back and forth between branch.

Do add and commit first (or git stash), then switch branch (with git switch rather than git checkout (since Git 2.23).

If you want to update master only with the new changes (and not the previous 3 commits), I would recommend, especially if you are the only one working on feature, to do an interactive rebase of feature first, in which you reorder commits, and put the last one first:

You cannot use git bundle because:

As no direct connection between the repositories exists, the user must specify a basis for the bundle that is held by the destination repository: the bundle assumes that all objects in the basis are already in the destination repository.

_{From git bundle documentation}

In your case the new repository does not share anything with the old one, except for the working directory, which is not enough. In summary the last commit of the old repo should have the same hash of the first commit in the new repo.

You have another way, git format-patch and git am:

1. First you need to create a patch for each commit (except the first one) in the new repository:

Yes, you can use manual immediate here - you can also use AckMode.RECORD and the container will automatically commit each offset after the record has been processed.

https://docs.spring.io/spring-kafka/docs/current/reference/html/#committing-offsets

All build folders should be ignored

It is NOT GUARANTEED that "the 1st, classA.doSomething() method will always finish and commit the transaction before the 2nd classB.complete() async call check the status of the same record".

Transactions are implemented as some kind of interceptors appropriate for the framework (this is true for CDI too). The method marked @Transactional is intercepted by the framework, so the transaction will not end before the closing } of the method. As a matter of fact, if the transaction was started by another method higher in the stack, it will end even later.

So, ClassB has plenty of time to run and see inconsistent state.

I would place the 1st part of doSomething in a separate REQUIRES_NEW transaction method (you may need to place it in a different class, depending on how you configured transaction interceptors; if you are using AOP, Spring may be able to intercept calls to methods of the same object, otherwise it relies on the injected proxy object to do the interception and calling a method through this will not activate the interceptor; again this is true for other frameworks as well, like CDI and EJB). The method doSomething calls the 1st part method, which finishes in a new transaction, then ClassB can continue asynchronously.

Now, in that case (as correctly pointed out in the comment), there is a chance that the 1st transaction succeeds and the 2nd fails. If this is the case, you will have to put logic in the system about how to compensate for this inconsistent state. Frameworks cannot deal with it because there is not one recipe, it is a per case "treatment". Some thoughts, in case they help: make sure that the state of the system after the 1st transaction clearly says that the second transaction should complete "shortly after". E.g. keep a "1st tx committed at" field; a scheduled task can check this timestamp and take action if it is too far in the past. JMS gives you all this - you get retries and a dead letter queue for the failed cases.

No, it's by design. Here is a comment from the source code:

You've used -Xms to force the JVM to get ~30GB at JVM startup.

It has tried, and failed. It only obtained 8GB. It needs another 22-ish GB but cannot get it. That is what the error message is telling you. This is consistent with a dump that says the heap is only 8GB.

You're asking for more than the OS will provide. You'll need to figure out what's going on in the OS in general.

Your application code is probably not involved. The JVM is still initializing its heap in accordance with your command-line options.

You can't do this from command level. But I guess you could write container_commands script to rename your docker-compose file from docker-compose.dev.yml to docker-compose.yml:

You can use the container_commands key to execute commands that affect your application source code. Container commands run after the application and web server have been set up and the application version archive has been extracted, but before the application version is deployed.

UPDATE 12 Jun 2021

I tried to replicate the issue using simplified setup with just docker-compose.prod.yml and Docker running on 64bit Amazon Linux 2 3.4.1 EB platform.

docker-compose.prod.yml