I've scoured several different posts but there doesn't appear to be any that match with this exact issue of an "apparent" branch renaming occurring but nothing seeming to line up.
Essentially, I've been trying to delete a remote branch off of an enterprise git version but I've been getting rejected and I was wondering if there was any additional steps I can try out?
here is the following CLI information:
| => git branch -a
* master
remotes/origin/HEAD -> origin/master
remotes/origin/master
remotes/origin/releases/v1.7.2_log4j2
(base)
| ~/Documents/<repo> # (user)
| => git push origin -d releases/v1.7.2_log4j2
To https://github.<company>.com/<org>/<repo>.git
! [remote rejected] releases/v1.7.2_log4j2 (branch releases/v1.7.2_log4j2 is being renamed)
error: failed to push some refs to 'https://github.<company>.com/<org>/<repo>.git'
My git version: 2.24.3 (Apple Git-128).
EDIT: there are no branch protection rules that apply to this branch and I have tried the command in the suggestions of git push -d origin releases<1.7.2_log4j2 with the same result
This looks like a github issue. There is a github-community thread where someone got the exact same message and it turned out to be a flag that was set within the github system that marked the branch as being renamed at the moment. They had to ask the github-support to clear that flag and then were able to delete the branch.
You seem to have your parameters backwards. Try
git push -d origin releases/v1.7.2_log4j2
I have a Github organization.
I created a repository and a team to work on it.
I want to restrict push to any branch to it's creator by the default.
So that no one can push to someone's else branch.
Is there any method to do that other than adding rule for every branch manually?
I tried to add rules manually, but it's time consuming cause there are many people joining the team.
Update:
I went to my organization -> teams.
Selected the team, went to members, selected a member.
Clicked on "manage access" next to one repository, clicked "edit".
Set "Base permissions" to "Write".
Set "Repository creation" to "Disabled".
Everything else is left unchecked.
I won't comment on whether or not this is a good idea.
Suffice to say I was annoyed once leading me to create the following update hook to apply to the canonical repo (note however that Github does not allow custom update hooks so you're out of luck there):
#!/usr/bin/env python
import os
import re
import sys
from pathlib import Path
from subprocess import check_output
branch = sys.argv[1]
old_commit = sys.argv[2]
new_commit = sys.argv[3]
zero = "0000000000000000000000000000000000000000"
branch_pattern = 'feature/.+'
def get_author(commit):
return str(check_output(['git', '--no-pager', 'show', '-s', "--format='%an'", commit]).strip(), 'utf-8')
def allow(message=None):
if message:
print(message)
exit(0)
def deny(message=None):
if message:
print(message)
exit(1)
# if this isn't a feature branch bail
if not re.match(branch_pattern, branch):
allow()
# if the update is a delete bail
if new_commit == zero:
allow("update: deleting branch '%s': OK" % branch)
# if this is the first commit on the branch bail
if old_commit == zero:
allow("update: creating branch '%s': OK" % branch)
branch_log = Path('.git', 'logs', 'refs', 'heads').joinpath(*branch.split(os.path.sep))
with open(branch_log, 'r') as log:
first_commit = log.readline(81).split(sep=' ', maxsplit=1)[1]
branch_author = get_author(first_commit)
new_commit_author = get_author(new_commit)
print("update: branch = '%s'; branch author = %s; commit author = %s" % (branch, branch_author, new_commit_author))
if new_commit_author == branch_author:
allow("update: commit author == branch author: OK")
else:
deny(
"update: branch author != commit author: REJECTED\n"
"update: create a branch for your changes from the tip of %s and request a pull instead"
% branch
)
Organization owners and people with admin permissions for organization-owned repositories can enforce branch restrictions so that only certain users or teams are able to push to a protected branch.
For more info, see here
I can commit loads of changes, but nothing gets to github.
Its only when I manually click the PUSH function from the menu that it pushes to github.
How can I get it to do this automatically when I commit?
These are my VS GIT settings:
// Whether git is enabled
"git.enabled": true,
// Path to the git executable
"git.path": null,
// Whether auto refreshing is enabled
"git.autorefresh": true,
// Whether auto fetching is enabled
"git.autofetch": true,
// Confirm before synchronizing git repositories
"git.confirmSync": true,
// Controls the git badge counter. `all` counts all changes. `tracked` counts only the tracked changes. `off` turns it off.
"git.countBadge": "all",
// Controls what type of branches are listed when running `Checkout to...`. `all` shows all refs, `local` shows only the local branchs, `tags` shows only tags and `remote` shows only remote branches.
"git.checkoutType": "all",
// Ignores the legacy Git warning
"git.ignoreLegacyWarning": false,
// Ignores the warning when there are too many changes in a repository
"git.ignoreLimitWarning": false,
// The default location where to clone a git repository
"git.defaultCloneDirectory": null,
// Commit all changes when there are not staged changes.
"git.enableSmartCommit": false,
According to this issue on GitHub, this feature does not exist and is not planned to be added.
They suggest using Git hooks to achieve this behavior.
Something like this:
#!/usr/bin/env bash
branch_name=`git symbolic-ref --short HEAD`
retcode=$?
# Only push if branch_name was found (my be empty if in detached head state)
if [ $retcode = 0 ] ; then
#Only push if branch_name is master
if [[ $branch_name = "master" ]] ; then
echo
echo "**** Pushing current branch $branch_name to origin ****"
echo
git push origin $branch_name;
fi
fi
You can check this answer for more details and options.
What is the best way to move a Git repository with all branches and full history from Bitbucket to GitHub?
Is there a script or a list of commands I have to use?
It's very simple.
Create a new empty repository in GitHub (without a README or license, you can add them later) and the following screen will show.
In the import code option, paste your Bitbucket repository's URL and voilà!!
You can refer to the GitHub page "Duplicating a repository"
It uses:
git clone --mirror: to clone every references (commits, tags, branches)
git push --mirror: to push everything
That would give:
git clone --mirror https://bitbucket.org/exampleuser/repository-to-mirror.git
# Make a bare mirrored clone of the repository
cd repository-to-mirror.git
git remote set-url --push origin https://github.com/exampleuser/mirrored
# Set the push location to your mirror
git push --mirror
As Noted in the comments by L S:
it is easier to use the Import Code feature from GitHub described by MarMass.
See https://github.com/new/import
Unless... your repo includes a large file: the problem is, the import tool will fail without a clear error message. Only GitHub Support would be able to diagnose what happened.
In case you couldn't find the "Import code" button on GitHub, you can:
Directly open GitHub Importer and enter the URL. It will look like:
Give it a name (or it will import the name automatically)
Select Public or Private repository
Click Begin Import
In May 2016, GitHub announced the ability to "Import repositories with large files".
Se Moving Repository from Bitbucket to GitHub.
This helped me move from one Git provider to another. At the end of it, all the commits were in the destination Git repository. Simple and straightforward.
git remote rename origin bitbucket
git remote add origin https://github.com/edwardaux/Pipelines.git
git push origin master
Once I was happy that the push had been successful to GitHub, I could
delete the old remote by issuing:
git remote rm bitbucket
I had the reverse use case of importing an existing repository from GitHub to Bitbucket.
Bitbucket offers an Import tool as well. The only necessary step is to add URL to repository.
It looks like:
There is the Importing a repository with GitHub Importer
If you have a project hosted on another version control system as Mercurial, you can automatically import it to GitHub using the GitHub Importer tool.
In the upper-right corner of any page, click, and then click Import repository.
Under "Your old repository's clone URL", type the URL of the project you want to import.
Choose your user account or an organization to own the repository, then type a name for the repository on GitHub.
Specify whether the new repository should be public or private.
Public repositories are visible to any user on GitHub, so you can benefit from GitHub's collaborative community.
Public or private repository radio buttonsPrivate repositories are only available to the repository owner, as well as any collaborators you choose to share with.
Review the information you entered, then click Begin import.
You'll receive an email when the repository has been completely imported.
Importing your projects to GitHub
Importing a repository with GitHub Importer
I found this question several months ago when I was trying to do the same thing, and was underwhelmed by the answers given. They all seemed to deal with importing from Bitbucket to GitHub one repository at a time, either via commands issued à la carte, or via the GitHub importer.
I grabulated the code from a GitHub project called gitter and modified it to suite my needs.
You can fork the gist, or take the code from here:
#!/usr/bin/env ruby
require 'fileutils'
# Originally -- Dave Deriso -- deriso#gmail.com
# Contributor -- G. Richard Bellamy -- rbellamy#terradatum.com
# If you contribute, put your name here!
# To get your team ID:
# 1. Go to your GitHub profile, select 'Personal Access Tokens', and create an Access token
# 2. curl -H "Authorization: token <very-long-access-token>" https://api.github.com/orgs/<org-name>/teams
# 3. Find the team name, and grabulate the Team ID
# 4. PROFIT!
#----------------------------------------------------------------------
#your particulars
#access_token = ''
#team_id = ''
#org = ''
#----------------------------------------------------------------------
#the version of this app
#version = "0.2"
#----------------------------------------------------------------------
#some global parameters
#create = false
#add = false
#migrate = false
#debug = false
#done = false
#error = false
#----------------------------------------------------------------------
#fancy schmancy color scheme
class String; def c(cc); "\e[#{cc}m#{self}\e[0m" end end
#200.to_i.times{ |i| print i.to_s.c(i) + " " }; puts
#sep = "-".c(90)*95
#sep_pref = ".".c(90)*95
#sep_thick = "+".c(90)*95
#----------------------------------------------------------------------
# greetings
def hello
puts #sep
puts "BitBucket to GitHub migrator -- v.#{#version}".c(95)
#puts #sep_thick
end
def goodbye
puts #sep
puts "done!".c(95)
puts #sep
exit
end
def puts_title(text)
puts #sep, "#{text}".c(36), #sep
end
#----------------------------------------------------------------------
# helper methods
def get_options
require 'optparse'
n_options = 0
show_options = false
OptionParser.new do |opts|
opts.banner = #sep +"\nUsage: gitter [options]\n".c(36)
opts.version = #version
opts.on('-n', '--name [name]', String, 'Set the name of the new repo') { |value| #repo_name = value; n_options+=1 }
opts.on('-c', '--create', String, 'Create new repo') { #create = true; n_options+=1 }
opts.on('-m', '--migrate', String, 'Migrate the repo') { #migrate = true; n_options+=1 }
opts.on('-a', '--add', String, 'Add repo to team') { #add = true; n_options+=1 }
opts.on('-l', '--language [language]', String, 'Set language of the new repo') { |value| #language = value.strip.downcase; n_options+=1 }
opts.on('-d', '--debug', 'Print commands for inspection, doesn\'t actually run them') { #debug = true; n_options+=1 }
opts.on_tail('-h', '--help', 'Prints this little guide') { show_options = true; n_options+=1 }
#opts = opts
end.parse!
if show_options || n_options == 0
puts #opts
puts "\nExamples:".c(36)
puts 'create new repo: ' + "\t\tgitter -c -l javascript -n node_app".c(93)
puts 'migrate existing to GitHub: ' + "\tgitter -m -n node_app".c(93)
puts 'create repo and migrate to it: ' + "\tgitter -c -m -l javascript -n node_app".c(93)
puts 'create repo, migrate to it, and add it to a team: ' + "\tgitter -c -m -a -l javascript -n node_app".c(93)
puts "\nNotes:".c(36)
puts "Access Token for repo is #{#access_token} - change this on line 13"
puts "Team ID for repo is #{#team_id} - change this on line 14"
puts "Organization for repo is #{#org} - change this on line 15"
puts 'The assumption is that the person running the script has SSH access to Bitbucket,'
puts 'and GitHub, and that if the current directory contains a directory with the same'
puts 'name as the repo to migrated, it will deleted and recreated, or created if it'
puts 'doesn\'t exist - the repo to migrate is mirrored locally, and then created on'
puts 'GitHub and pushed from that local clone.'
puts 'New repos are private by default'
puts "Doesn\'t like symbols for language (ex. use \'c\' instead of \'c++\')"
puts #sep
exit
end
end
#----------------------------------------------------------------------
# git helper methods
def gitter_create(repo)
if #language
%q[curl https://api.github.com/orgs/] + #org + %q[/repos -H "Authorization: token ] + #access_token + %q[" -d '{"name":"] + repo + %q[","private":true,"language":"] + #language + %q["}']
else
%q[curl https://api.github.com/orgs/] + #org + %q[/repos -H "Authorization: token ] + #access_token + %q[" -d '{"name":"] + repo + %q[","private":true}']
end
end
def gitter_add(repo)
if #language
%q[curl https://api.github.com/teams/] + #team_id + %q[/repos/] + #org + %q[/] + repo + %q[ -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ] + #access_token + %q[" -d '{"permission":"pull","language":"] + #language + %q["}']
else
%q[curl https://api.github.com/teams/] + #team_id + %q[/repos/] + #org + %q[/] + repo + %q[ -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ] + #access_token + %q[" -d '{"permission":"pull"}']
end
end
def git_clone_mirror(bitbucket_origin, path)
"git clone --mirror #{bitbucket_origin}"
end
def git_push_mirror(github_origin, path)
"(cd './#{path}' && git push --mirror #{github_origin} && cd ..)"
end
def show_pwd
if #debug
Dir.getwd()
end
end
def git_list_origin(path)
"(cd './#{path}' && git config remote.origin.url && cd ..)"
end
# error checks
def has_repo
File.exist?('.git')
end
def has_repo_or_error(show_error)
#repo_exists = has_repo
if !#repo_exists
puts 'Error: no .git folder in current directory'.c(91) if show_error
#error = true
end
"has repo: #{#repo_exists}"
end
def has_repo_name_or_error(show_error)
#repo_name_exists = !(defined?(#repo_name)).nil?
if !#repo_name_exists
puts 'Error: repo name missing (-n your_name_here)'.c(91) if show_error
#error = true
end
end
#----------------------------------------------------------------------
# main methods
def run(commands)
if #debug
commands.each { |x| puts(x) }
else
commands.each { |x| system(x) }
end
end
def set_globals
puts_title 'Parameters'
#git_bitbucket_origin = "git#bitbucket.org:#{#org}/#{#repo_name}.git"
#git_github_origin = "git#github.com:#{#org}/#{#repo_name}.git"
puts 'debug: ' + #debug.to_s.c(93)
puts 'working in: ' + Dir.pwd.c(93)
puts 'create: ' + #create.to_s.c(93)
puts 'migrate: ' + #migrate.to_s.c(93)
puts 'add: ' + #add.to_s.c(93)
puts 'language: ' + #language.to_s.c(93)
puts 'repo name: '+ #repo_name.to_s.c(93)
puts 'bitbucket: ' + #git_bitbucket_origin.to_s.c(93)
puts 'github: ' + #git_github_origin.to_s.c(93)
puts 'team_id: ' + #team_id.to_s.c(93)
puts 'org: ' + #org.to_s.c(93)
end
def create_repo
puts_title 'Creating'
#error checks
has_repo_name_or_error(true)
goodbye if #error
puts #sep
commands = [
gitter_create(#repo_name)
]
run commands
end
def add_repo
puts_title 'Adding repo to team'
#error checks
has_repo_name_or_error(true)
goodbye if #error
puts #sep
commands = [
gitter_add(#repo_name)
]
run commands
end
def migrate_repo
puts_title "Migrating Repo to #{#repo_provider}"
#error checks
has_repo_name_or_error(true)
goodbye if #error
if Dir.exists?("#{#repo_name}.git")
puts "#{#repo_name} already exists... recursively deleting."
FileUtils.rm_r("#{#repo_name}.git")
end
path = "#{#repo_name}.git"
commands = [
git_clone_mirror(#git_bitbucket_origin, path),
git_list_origin(path),
git_push_mirror(#git_github_origin, path)
]
run commands
end
#----------------------------------------------------------------------
#sequence control
hello
get_options
#do stuff
set_globals
create_repo if #create
migrate_repo if #migrate
add_repo if #add
#peace out
goodbye
Then, to use the script:
# create a list of repos
foo
bar
baz
# execute the script, iterating over your list
while read p; do ./bitbucket-to-github.rb -a -n $p; done<repos
# good enough
In case you want to move your local Git repository to another upstream, you can also do this:
To get the current remote URL:
git remote get-url origin
will show something like:
https://bitbucket.com/git/myrepo
To set new remote repository:
git remote set-url origin git#github.com:folder/myrepo.git
now push contents of current (develop) branch:
git push --set-upstream origin develop
You now have a full copy of the branch in the new remote.
Optionally, return to original git-remote for this local folder:
git remote set-url origin https://bitbucket.com/git/myrepo
It gives the benefit you can now get your new Git repository from GitHub in another folder so that you have two local folders both pointing to the different remotes, the previous (Bitbucket) and the new one both available.
I made the following Bash script in order to clone all of my Bitbucket (user) repositories to GitHub as private repositories.
Requirements:
jq (command-line JSON processor) | macOS: brew install jq
Steps:
Go to Personal access tokens and create an access token. We only need the "repo" scope.
Save the move_me.sh script in a working folder and edit the file as needed.
Don't forget to chmod 755
Run! ./move_me.sh
Enjoy the time you have saved.
Notes:
It will clone the Bitbucket repositories inside the directory the script resides (your working directory).
This script does not delete your Bitbucket repositories.
Need to move to public repositories on GitHub?
Find and change the "private": true to "private": false below.
Moving an organization's repositories?
Check out the developer guide. It's a couple of edits away.
Happy moving.
#!/bin/bash
BB_USERNAME=your_bitbucket_username
BB_PASSWORD=your_bitbucket_password
GH_USERNAME=your_github_username
GH_ACCESS_TOKEN=your_github_access_token
###########################
pagelen=$(curl -s -u $BB_USERNAME:$BB_PASSWORD https://api.bitbucket.org/2.0/repositories/$BB_USERNAME | jq -r '.pagelen')
echo "Total number of pages: $pagelen"
hr () {
printf '%*s\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' -
}
i=1
while [ $i -le $pagelen ]
do
echo
echo "* Processing Page: $i..."
hr
pageval=$(curl -s -u $BB_USERNAME:$BB_PASSWORD https://api.bitbucket.org/2.0/repositories/$BB_USERNAME?page=$i)
next=$(echo $pageval | jq -r '.next')
slugs=($(echo $pageval | jq -r '.values[] | .slug'))
repos=($(echo $pageval | jq -r '.values[] | .links.clone[1].href'))
j=0
for repo in ${repos[#]}
do
echo "$(($j + 1)) = ${repos[$j]}"
slug=${slugs[$j]}
git clone --bare $repo
cd "$slug.git"
echo
echo "* $repo cloned, now creating $slug on GitHub..."
echo
read -r -d '' PAYLOAD <<EOP
{
"name": "$slug",
"description": "$slug - moved from Bitbucket",
"homepage": "https://github.com/$slug",
"private": true
}
EOP
curl -H "Authorization: token $GH_ACCESS_TOKEN" --data "$PAYLOAD" \
https://api.github.com/user/repos
echo
echo "* mirroring $repo to GitHub..."
echo
git push --mirror "git#github.com:$GH_USERNAME/$slug.git"
j=$(( $j + 1 ))
hr
cd ..
done
i=$(( $i + 1 ))
done
Here are the steps to move a private Git repository:
Step 1: Create a GitHub repository
First, create a new private repository on GitHub. It’s important to keep the repository empty, e.g., don’t check option Initialize this repository with a README when creating the repository.
Step 2: Move existing content
Next, we need to fill the GitHub repository with the content from our Bitbucket repository:
Check out the existing repository from Bitbucket:
git clone https://USER#bitbucket.org/USER/PROJECT.git
Add the new GitHub repository as upstream remote of the repository checked out from Bitbucket:
cd PROJECT
git remote add upstream https://github.com:USER/PROJECT.git
Push all branches (below: just master) and tags to the GitHub
repository:
git push upstream master
git push --tags upstream
Step 3: Clean up the old repository
Finally, we need to ensure that developers don’t get confused by having two repositories for the same project. Here is how to delete the Bitbucket repository:
Double-check that the GitHub repository has all content
Go to the web interface of the old Bitbucket repository
Select menu option Setting → Delete repository
Add the URL of the new GitHub repository as the redirect URL
With that, the repository completely settled into its new home at GitHub. Let all the developers know!
Following on from #MarMass' answer, if the GitHub importer is constantly redirecting you to the authentication screen, you'll need to create an App Password in BitBucket in order to import your private repository:
Go to Bitbucket > Personal Settings > App Passwords.
Create an app password with repository read access.
When prompted for your username/password in the GitHub importer, enter your BitBucket username, and the token created above as your password.
After managing to sort out the authentication issue, my imports also errored out with the following message: "There was an error pushing commits to GitHub.".
The issue here, at least for me, was that my GitHub account was set to "Block command line pushes that expose my email", and the repository I was attempting to import from Bitbucket contained commits from my personal email address. After temporarily disabling this setting (GitHub > Settings > Email) I was good to go.
The simplest way of doing it:
git remote rename origin repo_bitbucket
git remote add origin https://github.com/abc/repo.git
git push origin master
Once the push to GitHub is successful, delete the old remote by running:
git remote rm repo_bitbucket
How do you create an orphan branch in libgit2sharp?
All i could find are methods which create a branch which points to a commit.
I'm looking for an effect similar to the command:
git checkout --orphan BRANCH_NAME
git checkout --orphan BRANCH_NAME actually moves the HEAD to an unborn branch BRANCH_NAME without altering the working directory nor the index.
You can perform a similar operation with LibGit2Sharp by updating the target of the HEAD reference with repo.Refs.UpdateTarget() method.
The following test demonstrates this
[Fact]
public void CanCreateAnUnbornBranch()
{
string path = CloneStandardTestRepo();
using (var repo = new Repository(path))
{
// No branch named orphan
Assert.Null(repo.Branches["orphan"]);
// HEAD doesn't point to an unborn branch
Assert.False(repo.Info.IsHeadUnborn);
// Let's move the HEAD to this branch to be created
repo.Refs.UpdateTarget("HEAD", "refs/heads/orphan");
Assert.True(repo.Info.IsHeadUnborn);
// The branch still doesn't exist
Assert.Null(repo.Branches["orphan"]);
// Create a commit against HEAD
var signature = new Signature("Me", "me#there.com", DateTimeOffset.Now);
Commit c = repo.Commit("New initial root commit", signature, signature);
// Ensure this commit has no parent
Assert.Equal(0, c.Parents.Count());
// The branch now exists...
Branch orphan = repo.Branches["orphan"];
Assert.NotNull(orphan);
// ...and points to that newly created commit
Assert.Equal(c, orphan.Tip);
}
}