Ich habe ein GitHub-Firmenkonto und möchte alle darin enthaltenen Repositorys sichern, um alles Neue zu berücksichtigen, das möglicherweise zu Automatisierungszwecken erstellt wird. Ich hatte so etwas gehofft:

git clone git@github.com:company/*.git 

oder ähnliches würde funktionieren, aber es scheint den Platzhalter dort nicht zu mögen.

Gibt es in Git eine Möglichkeit, alles zu klonen und dann abzurufen, vorausgesetzt, man verfügt über die entsprechenden Berechtigungen?

Ich denke nicht, dass es so möglich ist. Am besten suchen und durchsuchen Sie eine Liste der Repositorys einer Organisation mithilfe der API.

Versuche dies:

• Erstellen Sie ein API-Token, indem Sie zu Kontoeinstellungen -> Anwendungen gehen
• Rufen Sie an: http://${GITHUB_BASE_URL}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN}
• Die Antwort ist ein JSON-Array von Objekten. Jedes Objekt enthält Informationen zu einem der Repositorys unter dieser Organisation. Ich denke, in Ihrem Fall werden Sie speziell nach der ssh_urlImmobilie suchen .
• Dann git clonejeder dieser ssh_urls.

Es ist ein bisschen zusätzliche Arbeit, aber für GitHub ist eine ordnungsgemäße Authentifizierung erforderlich.

Ersetzen Sie unter Windows und allen UNIX / LINUX- Systemen mit Git Bash oder einem anderen TerminalYOURUSERNAME durch Ihren Benutzernamen und verwenden Sie:

CNTX={users|orgs}; NAME={username|orgname}; PAGE=1
curl "https://api.github.com/$CNTX/$NAME/repos?page=$PAGE&per_page=100" |
  grep -e 'git_url*' |
  cut -d \" -f 4 |
  xargs -L1 git clone

• Stellen Sie CNTX=usersund ein NAME=yourusername, um alle Ihre Repositorys herunterzuladen.
• Legen Sie CNTX=orgsund fest NAME=yourorgname, um alle Repositorys Ihrer Organisation herunterzuladen.

Die maximale Seitengröße beträgt 100, daher müssen Sie diese mehrmals mit der richtigen Seitenzahl aufrufen, um alle Ihre Repositorys abzurufen ( PAGEauf die gewünschte Seitenzahl eingestellt , die Sie herunterladen möchten).

Hier ist ein Shell-Skript, das die oben genannten Aufgaben ausführt : https://gist.github.com/erdincay/4f1d2e092c50e78ae1ffa39d13fa404e

Organisations-Repositorys

Versuchen Sie den folgenden Shell-Einzeiler, um alle Repos aus Ihrer Organisation zu klonen:

GHORG=company; curl "https://api.github.com/orgs/$GHORG/repos?per_page=1000" | grep -o 'git@[^"]*' | xargs -L1 git clone

Benutzer-Repositorys

Klonen aller mit Git-Repository-URLs:

GHUSER=CHANGEME; curl "https://api.github.com/users/$GHUSER/repos?per_page=1000" | grep -o 'git@[^"]*' | xargs -L1 git clone

Klonen aller mit Klon-URL:

GHUSER=CHANGEME; curl "https://api.github.com/users/$GHUSER/repos?per_page=1000" | grep -w clone_url | grep -o '[^"]\+://.\+.git' | xargs -L1 git clone

Hier ist die nützliche Shell-Funktion, die den Startdateien des Benutzers hinzugefügt werden kann (mit curl+ jq):

# Usage: gh-clone-user (user)
gh-clone-user() {
  curl -sL "https://api.github.com/users/$1/repos?per_page=1000" | jq -r '.[]|.clone_url' | xargs -L1 git clone
}

Private Repositories

Wenn Sie die privaten Repos klonen müssen, können Sie ein Autorisierungstoken wie folgt in Ihren Header einfügen:

-H 'Authorization: token <token>'

oder übergeben Sie es in param ( ?access_token=TOKEN), zum Beispiel:

curl -s "https://api.github.com/users/$GHUSER/repos?access_token=$GITHUB_API_TOKEN&per_page=1000" | grep -w clone_url | grep -o '[^"]\+://.\+.git' | xargs -L1 git clone

Anmerkungen:

• Fügen Sie type=privateIhrer Abfragezeichenfolge hinzu, um nur private Repositorys abzurufen .
• Eine andere Möglichkeit ist die Verwendung hubnach der Konfiguration Ihres API-Schlüssels.

Siehe auch:

• GitHub REST API v3 - Listen Sie Ihre Repositorys auf
• So laden Sie GitHub Release über die Befehlszeile von einem privaten Repo herunter .
• Wie kann man die Liste aller Github-Repositories einer Person abrufen? .

<sup>Hinweise :
- Um die Geschwindigkeit zu erhöhen, stellen Sie die Anzahl der parallelen Prozesse ein, indem Sie den -PParameter für xargs( -P4= 4 Prozesse) angeben.
- Wenn Sie die GitHub-Grenzwerte erhöhen müssen, versuchen Sie, sich durch Angabe Ihres API-Schlüssels zu authentifizieren.
- Hinzufügen --recursive, um in die registrierten Submodule zurückzukehren, und Aktualisieren aller darin verschachtelten Submodule.</sup>

Dieser Kern erledigt die Aufgabe in einer Zeile in der Befehlszeile:

curl -s https://api.github.com/orgs/[your_org]/repos?per_page=200 | ruby -rubygems -e 'require "json"; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo["ssh_url"]} ]}'

Ersetzen [your_org]Sie durch den Namen Ihrer Organisation. Und stellen Sie Ihre per_pagebei Bedarf ein.

AKTUALISIEREN:

Wie von ATutorMe erwähnt, beträgt die maximale Seitengröße laut GitHub-Dokumenten 100 .

Wenn Sie mehr als 100 Repos haben, müssen Sie pageIhrer URL einen Parameter hinzufügen und können den Befehl für jede Seite ausführen.

curl -s "https://api.github.com/orgs/[your_org]/repos?page=2&per_page=100" | ruby -rubygems -e 'require "json"; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo["ssh_url"]} ]}'

Hinweis: Der Standardparameter per_pageist 30.

Gehen Sie zu Kontoeinstellungen -> Anwendung und erstellen Sie einen API-Schlüssel.
Geben Sie dann den API-Schlüssel, die URL der Github-Instanz und den Organisationsnamen in das folgende Skript ein

#!/bin/bash

# Substitute variables here
ORG_NAME="<ORG NAME>"
ACCESS_TOKEN="<API KEY>"
GITHUB_INSTANCE="<GITHUB INSTANCE>

URL="https://${GITHUB_INSTANCE}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN}"

curl ${URL} | ruby -rjson -e 'JSON.load(STDIN.read).each {|repo| %x[git clone #{repo["ssh_url"]} ]}'

Speichern Sie das in einer Datei, chmod u+xder Datei, und führen Sie sie dann aus.

_{Vielen Dank an Arnaud für den Ruby-Code.}

Also werde ich auch meine Antwort hinzufügen. :) (Ich fand es einfach)

Liste abrufen (ich habe die Firma "Magento" verwendet):

curl -si https://api.github.com/users/magento/repos | grep ssh_url | cut -d '"' -f4

Verwenden Sie clone_urlstattdessen ssh_url, um den HTTP-Zugriff zu verwenden.

Also, lasst uns sie alle klonen! :) :)

curl -si https://api.github.com/users/magento/repos | \
    grep ssh_url | cut -d '"' -f4 | xargs -i git clone {}

Wenn Sie private Repos abrufen möchten, fügen Sie einfach den Parameter GET hinzu ?access_token=YOURTOKEN

Ich fand einen Kommentar in der Liste @seancdavis als sehr hilfreich, insbesondere weil ich wie das Originalposter alle Repos für einen schnellen Zugriff synchronisieren wollte, von denen jedoch die überwiegende Mehrheit privat war.

curl -u [[USERNAME]] -s https://api.github.com/orgs/[[ORGANIZATION]]/repos?per_page=200 |
  ruby -rubygems -e 'require "json"; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo["ssh_url"]} ]}'

Ersetzen Sie [[USERNAME]] durch Ihren Github-Benutzernamen und [[ORGANISATION]] durch Ihre Github-Organisation. Die Ausgabe (JSON-Repo-Metadaten) wird an ein einfaches Ruby-Skript übergeben:

# bring in the Ruby json library
require "json"

# read from STDIN, parse into ruby Hash and iterate over each repo
JSON.load(STDIN.read).each do |repo|
  # run a system command (re: "%x") of the style "git clone <ssh_url>"
  %x[git clone #{repo["ssh_url"]} ]
end

Ich habe ein Skript mit Python3 und Github APIv3 erstellt

https://github.com/muhasturk/gitim

Renn einfach

./gitim

Dieser Python-Einzeiler macht das, was Sie brauchen. Es:

• Überprüft Github auf Ihre verfügbaren Repos

• macht für jeden einen Systemaufruf an git clone

  python -c "import json, urllib, os; [os.system('git clone ' + r['ssh_url']) for r in json.load(urllib.urlopen('https://api.github.com/orgs/<<ORG_NAME>>/repos?per_page=200'))]"
  

curl -s https://api.github.com/orgs/[GITHUBORG_NAME]/repos | grep clone_url | awk -F '":' '{ print $2 }' | sed 's/\"//g' | sed 's/,//' | while read line; do git clone "$line"; done

Einfache Lösung:

NUM_REPOS=1000
DW_FOLDER="Github_${NUM_REPOS}_repos"
mkdir ${DW_FOLDER}
cd ${DW_FOLDER}
for REPO in $(curl https://api.github.com/users/${GITHUB_USER}/repos?per_page=${NUM_REPOS} | awk '/ssh_url/{print $2}' | sed 's/^"//g' | sed 's/",$//g') ; do git clone ${REPO} ; done

Ich habe einige der oben genannten Befehle und Tools ausprobiert, aber festgestellt, dass sie zu mühsam sind. Deshalb habe ich ein anderes Befehlszeilen-Tool geschrieben, das dazu aufgerufen wurde github-dl.

Um es zu verwenden (vorausgesetzt, Sie haben nodejs installiert)

npx github-dl -d /tmp/test wires

Dies würde eine Liste aller Repos von erhalten wiresund Informationen in das testVerzeichnis schreiben , wobei die Autorisierungsdetails (Benutzer / Pass) verwendet werden, die Sie auf der CLI angeben.

Im Detail ist es

1. Fragt nach Authentifizierung (unterstützt 2FA)
2. Ruft eine Liste der Repos für Benutzer / Organisation über die Github-API ab
3. Hat Paginierung dafür, so dass mehr als 100 Repos unterstützt werden

Die Repos werden nicht geklont, sondern es wird eine .txtDatei geschrieben, in xargsdie Sie zum Klonen übergehen können , zum Beispiel:

cd /tmp/test
cat wires-repo-urls.txt | xargs -n2 git clone

# or to pull
cat /tmp/test/wires-repo-urls.txt | xargs -n2 git pull

Vielleicht ist das nützlich für Sie; Es sind nur ein paar Zeilen JS, daher sollte es einfach sein, sie an Ihre Bedürfnisse anzupassen

Dazu gibt es auch ein sehr nützliches npm-Modul . Es kann nicht nur klonen, sondern auch ziehen (um bereits vorhandene Daten zu aktualisieren).

Sie erstellen einfach eine Konfiguration wie folgt:

[{
   "username": "BoyCook",
   "dir": "/Users/boycook/code/boycook",
   "protocol": "ssh"
}]

und gitall clonezum Beispiel tun . Odergitall pull

Für den Fall, dass jemand nach einer Windows-Lösung sucht, gibt es hier eine kleine Funktion in PowerShell, um den Trick auszuführen (könnte Oneliner / Alias ​​sein, wenn nicht die Tatsache, dass ich sie brauche, um sowohl mit als auch ohne Proxy zu arbeiten).

function Unj-GitCloneAllBy($User, $Proxy = $null) {
    (curl -Proxy $Proxy "https://api.github.com/users/$User/repos?page=1&per_page=100").Content 
      | ConvertFrom-Json 
      | %{ $_.clone_url } 
      # workaround git printing to stderr by @wekempf aka William Kempf
      # https://github.com/dahlbyk/posh-git/issues/109#issuecomment-21638678
      | %{ & git clone $_ 2>&1 } 
      | % { $_.ToString() }
}

Wenn Sie also in der Praxis alle FOOpassenden Repos aus der Organisation klonen möchten BAR, können Sie den folgenden Einzeiler verwenden , für den jq und allgemeine Cli-Dienstprogramme erforderlich sind

curl 'https://api.github.com/orgs/FOO/repos?access_token=SECRET' |
  jq '.[] |
  .ssh_url' |
  awk '/BAR/ {print "git clone " $0 " & "}' |
  sh

Ein weiteres Shell-Skript mit Kommentaren, die alle Repositorys (öffentlich und privat) eines Benutzers klonen:

#!/bin/bash

USERNAME=INSERT_USERNAME_HERE
PASSWORD=INSERT_PASSWORD_HERE

# Generate auth header
AUTH=$(echo -n $USERNAME:$PASSWORD | base64)

# Get repository URLs
curl -iH "Authorization: Basic "$AUTH https://api.github.com/user/repos | grep -w clone_url > repos.txt

# Clean URLs (remove " and ,) and print only the second column
cat repos.txt | tr -d \"\, | awk '{print $2}'  > repos_clean.txt

# Insert username:password after protocol:// to generate clone URLs
cat repos_clean.txt |  sed "s/:\/\/git/:\/\/$USERNAME\:$PASSWORD\@git/g" > repos_clone.txt

while read FILE; do
    git clone $FILE
done <repos_clone.txt

rm repos.txt & rm repos_clone.txt

Erstellen Sie einen Bash-Alias ​​/ eine Bash-Funktion in Ihrem ~/.bashrc file

Ich habe dies für mein Team gelöst, indem ich in meinem einen Alias ​​/ Bash-Funk erstellt habe ~/.bashrc file

Schritte

Öffnen Sie ein Terminal oder eine Linux-Shell und öffnen Sie Folgendes ~/.bashrc file:

sudo nano ~/.bashrc

füge diese Funktion hinzu:

CloneAll() {
    # Make the url to the input github organization's repository page.
    ORG_URL="https://api.github.com/orgs/${1}/repos?per_page=200";

    # List of all repositories of that organization (seperated by newline-eol).
    ALL_REPOS=$(curl -s ${ORG_URL} | grep html_url | awk 'NR%2 == 0' \
                | cut -d ':' -f 2-3 | tr -d '",');

    # Clone all the repositories.
    for ORG_REPO in ${ALL_REPOS}; do
        git clone ${ORG_REPO}.git;
    done
}

Speichern und schließen Sie Ihre ~ / .bashrc-Datei und schließen Sie dann das Terminal. Sie müssen dies tun, oder die neue Funktion wird nicht initialisiert:

neues Terminal öffnen und ausprobieren:

CloneAll <your_github_org_name>

Beispiel : Wenn Ihre persönliche Github-Repo-URL https://github.com/awesome-async heißt, lautet der Befehl

CloneAll awesome-async

Wichtig

Das per_page=200am Ende der ersten Variablen festgelegte ORG_URLAnzahl der Repos, die geklont werden sollen. Achten Sie daher besonders darauf:

ORG_URL="https://api.github.com/orgs/${1}/repos?per_page=200";  <---- make sure this is what you want

Hoffe das hilft! :) :)

Sie können eine Liste der Repositorys curlabrufen, indem Sie diese Liste verwenden und dann mit einer Bash-Schleife durchlaufen:

GIT_REPOS=`curl -s curl https://${GITHUB_BASE_URL}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN} | grep ssh_url | awk -F': ' '{print $2}' | sed -e 's/",//g' | sed -e 's/"//g'`
for REPO in $GIT_REPOS; do
  git clone $REPO
done

Sie können das Open-Source-Tool verwenden, um eine Reihe von Github-Repositorys zu klonen: https://github.com/artiomn/git_cloner

Beispiel:

git_cloner --type github --owner octocat --login user --password user https://my_bitbucket

Verwenden Sie die JSON-API von api.github.com. Sie können das Codebeispiel in der Github-Dokumentation sehen: https://developer.github.com/v3/

Oder dort:

https://github.com/artiomn/git_cloner/blob/master/src/git_cloner/github.py

So klonen Sie nur private Repos mit einem Zugriffsschlüssel und Python 3 und dem installierten Anforderungsmodul:

ORG=company; ACCESS_KEY=0000000000000000000000000000000000000000; for i in $(python -c "import requests; print(' '.join([x['ssh_url'] for x in list(filter(lambda x: x['private'] ,requests.get('https://api.github.com/orgs/$ORG/repos?per_page=1000&access_token=$ACCESS_KEY').json()))]))"); do git clone $i; done;

Eine Python3-Lösung, die eine umfassende Paginierung über den LinkHeader enthält.

Voraussetzungen:

• Github API "Personal Access Token"
• pip3 install links-from-link-header
• Nabe

import json
import requests
from requests.auth import HTTPBasicAuth
import links_from_header

respget = lambda url: requests.get(url, auth=HTTPBasicAuth('githubusername', 'githubtoken'))

myorgname = 'abc'
nexturl = f"https://api.github.com/orgs/{myorgname}/repos?per_page=100"

while nexturl:
    print(nexturl)
    resp = respget(nexturl)

    linkheads = resp.headers.get('Link', None)
    if linkheads:
        linkheads_parsed = links_from_header.extract(linkheads)
        nexturl = linkheads_parsed.get('next', None)
    else:
        nexturl = None

    respcon = json.loads(resp.content)
    with open('repolist', 'a') as fh:
        fh.writelines([f'{respconi["full_name"]}\n' for respconi in respcon])

Dann können Sie verwenden xargsoder parallel und:cat repolist | parallel -I% hub clone %

Wenn Sie eine Liste von Repositorys in einer Liste wie dieser haben, funktioniert dieses Shell-Skript:

user="https://github.com/user/"

declare -a arr=("repo1", "repo2")

for i in "${arr[@]}"

do

   echo $user"$i"

   git clone $user"$i"

done 

Ich habe ein Beispiel-Batch-Skript erstellt. Sie können alle privaten / öffentlichen Repositories von github.com herunterladen. Nachdem ein Repository heruntergeladen wurde, wird es automatisch in eine Zip-Datei konvertiert.

@echo off
setlocal EnableDelayedExpansion
SET "username=olyanren"
SET "password=G....."
set "mypath=%cd%\"
SET "url=https://%username%:%password%@github.com/%username%/"
FOR /F "tokens=* delims=" %%i in (files.txt) do (
SET repo=%%i
rmdir /s /q !repo!
git clone "!url!!repo!.git"
cd !repo!
echo !mypath!
git archive --format=zip -o "!mypath!!repo!.zip" HEAD
cd ..
)

Hinweis: Die Datei files.txt sollte nur Repository-Namen enthalten wie:

repository1
repository2

Update vom 19. Mai

Verwenden Sie diesen Bash-Befehl für eine Organisation (privates Repo enthalten).

curl -u "{username}" "https://api.github.com/orgs/{org}/repos?page=1&per_page=100" | grep -o 'git@[^"]*' | xargs -L1 git clone

Die hier vorherrschenden Antworten berücksichtigen nicht, dass die Github-API trotz der Angaben in nur maximal 100 Repositorys zurückgibt per_page. Wenn Sie eine Github-Organisation mit mehr als 100 Repositorys klonen, müssen Sie den Paging-Links in der API-Antwort folgen.

Ich habe ein CLI-Tool geschrieben, um genau das zu tun :

clone-github-org -o myorg

Dadurch werden alle Repositorys in der myorgOrganisation in das aktuelle Arbeitsverzeichnis geklont.

Für Organisationen, auf die Sie mit privaten Repos zugreifen können:

curl -u <YOUR_GITHUB_USERNAME> -s https://api.github.com/orgs/<ORG_NAME>/repos?per_page=200 | ruby -rubygems -e ’require “json”; JSON.load(STDIN.read).each { |repo| %x[git clone #{repo[“html_url”]} ]}'

Es wird das verwendet html_url, sodass Sie nicht access_tokeneinfach Ihr Github-Passwort eingeben müssen, wenn Sie dazu aufgefordert werden.

Klonen Sie alle Ihre Repos, die keine Gabeln sind:

curl -u "username" https://api.github.com/user/repos\?page\=1\&per_page\=100 |
  jq -r 'map(select(.fork == false)) | .[] | .ssh_url' |
  xargs -L1 git clone

Klonen Sie Ihre Kernpunkte:

curl https://api.github.com/users/username/gists\?page\=1\&per_page\=100 |
   jq -r ".[] | .git_pull_url +\" '\" + (.files|keys|join(\"__\") + \"'\")" |
   xargs -L1 git clone

Dieser jqBefehl ist komplex, da der Name des Repos von Gists Hashes sind, sodass der Befehl alle Dateinamen mit dem Namen des Repos verknüpft

Sie können den JSON beliebig mit filtern jq

Installieren: sudo apt-get install jq

Im obigen Beispiel habe ich Gabeln folgendermaßen herausgefiltert : curl ... | jq -r 'map(select(.fork == false))' ...- nützlich, um keine Repos zu klonen, bei denen Sie gelegentliche Pull-Anfragen gestellt haben

jq unterstützt einige sehr erweiterte Funktionen. man jqist dein Freund

Sie können sich bei authentifizieren, curl -u "username" ... um auf private Repos zuzugreifen

Guthubs API-URLs

• Ihre Repos (müssen authentifiziert werden): https://api.github.com/user/repos\?page\=1\&per_page\=100
• Jeder Benutzer: https://api.github.com/users/other_username/repos\?page\=1\&per_page\=100
• Orgs: https://api.github.com/orgs/orgname/repos\?page\=1\&per_page\=100

Github API Docs für Repos

"""
Clone all public Github Repos

https://developer.github.com/v3/repos/#list-repositories-for-a-user
"""

import urllib.request, base64
import json
import os


def get_urls(username):
    url = f"https://api.github.com/users/{username}/repos?per_page=200"
    request = urllib.request.Request(url)
    result = urllib.request.urlopen(request)
    return json.load(result)


if __name__ == "__main__":
    for r in get_urls("MartinThoma"):
        if not os.path.isdir(r["name"]):
            print(f"Clone {r['name']}...")
            os.system("git clone " + r["ssh_url"])
        else:
            print(f"SKIP {r['name']}...")

Um alle Ihre eigenen privaten und öffentlichen Repos zu klonen, generieren Sie einfach ein neues Zugriffstoken mit Repos-Zugriff und verwenden Sie Folgendes:

(durch Ihr eigenes Zugriffstoken und Ihren eigenen Benutzernamen ersetzen)

for line in $(curl https://api.github.com/user/repos?access_token=ACCESS_TOKEN_HERE  | grep -o "git@github.com:YOUR_USER_NAME/[^ ,\"]\+");do git clone $line;done

Dadurch werden alle Repos im aktuellen Ordner geklont

Dies ist ein kleines Bash-Programm. Sie können es einfach in das Terminal einfügen und die Eingabetaste drücken