prs | 🔐 A secure, fast & convenient password manager CLI using GPG and git to sync

branchSources/github is a static API and you shouldn't use it. The author of the Job DSL plugin stopped supporting it. The safer option is to use a dynamic API. You can check which options are available on your Jenkins by using this URL:

Linker warning: function 'UserIdentify' not used in data stack usage calculation due to possible recursive calls

This message tells you that the compiler is unable to estimate the data stack usage of your code because it detected a possible recursive call. In case of recursive call, stack use depends on the data values at run-time so the compiler doesn't know it.

Normally not. However there is an issue in cypress, since v7.2: https://github.com/cypress-io/cypress/issues/16671

You can try to downgrade your cypress to 7.1 to evaluate if your performance-issue is related to this bug.

There are multiple ways to accomplish this, and none of them are even GitHub specific:

1. Lock down the develop branch starting a time X and ending at time Y. AFAIK most popular centralized Git repo tools have the ability for the admins to manually lock and unlock branches (either with an explicit lock or by adjusting permissions). Whether you can automate the timing would be tool dependent, but I assume you could write custom integrations, and if not, manually locking once per week isn't a big deal, especially since you would have to intervene manually to allow bug fixes to get in.
2. Add a custom integration "gated check-in" such that additional requirements exist during the desired time frame.
3. Don't lock down develop at all! This is actually what most people do. For example, in Git Flow you simply create a release branch for this exact reason. If you don't want to actually create the dedicated release branch, you don't have to; just remember the commit ID from develop that you cutoff and tested from, and if you don't have new PRs for bug fixes, simply release that commit ID and merge that commit ID into main. If you end up having bug fixes, you might as well create a release branch so there is a branch to PR the fixes into.

Whether you use Git Flow or not, I highly recommend option 3, for sanity purposes, and so you don't have to stop development during the release cycle.

Try deleting the offending "placeholder" shape and inserting a new, untouched placeholder using the PowerPoint UI. On my Mac with PowerPoint 2016 this is:

• View > Slide Master
• Select the desired slide-layout
• Slide Master > Insert Placeholder > Picture

You can adjust the size and position if you want, but otherwise leave it untouched and try again. Probably best to do all this with a new presentation and delete all but one of the slide layouts and all the slides, just to keep things simple.

Then use python-pptx to create a slide from that layout:

You need send data in Postman like below:

How can I get same HEAD for master and dev after merge?

You can't. Well, technically you could, but you probably don't want to.

A branch in git points to a commit; that commit points to other commits, back through history. Each of those commits is identified by a unique hash; if two different commits had the same hash, everything would be horribly broken. That hash covers both the contents of the repository, and all the metadata of the commit, including what parents it has.

So if two different branches point at the same hash, those branches are identical - not just identical in their current content, but identical in their entire history.

The only way for that to happen is to always use "fast-forward" merges, everywhere, so that all your branches are actually just pointers in a single line of commits. In practice, that means rebasing things, a lot - for instance, every hotfix will probably require rebasing the whole of develop, and then rebasing all open feature branches onto that new develop.

That's a lot of work, and a lot of things that can go wrong, to avoid this:

I had to merge an empty commit with no diff.

Git was smart enough to recognise that no actual changes were needed, even though you'd merged two unrelated commits (remember: a squash merge throws away all history on the feature branch). That is it solving the problem for you.

The other solution, as pointed out in comments, is not to merge the feature to two places in the first place. Merge release to master, and then merge master to develop.

PR should be updated automatically. If that doesn't happen try changing the target branch to something else and changing it back to main.

Buildx runs builds within a separate container, not directly in your docker engine. And the output of buildx does not store the resulting image in the local docker engine. This doesn't work when you get into multi-platform images anyway, so you typically push directly to the registry. It's much more efficient to avoid moving layers around that didn't change in the registry, and allows you to manage multi-platform images (everything loaded into the docker engine is dereferenced to a single platform).

If you really want to save the output to the local docker engine, you can use --load in the buildx command. However, the preferred option is to use the build-push-action that builds your tag directly and pushes it in one step. This would mean reordering your steps to determine the versions and other variables first, and then run the build against that. You can see an example of this in my own project which was assembled from various other docker examples out there.

Here's a quick untested attempt to make that change: