Jak sklonować wszystkie repozytoria jednocześnie z GitHub?

99

Mam firmowe konto GitHub i chcę wykonać kopię zapasową wszystkich repozytoriów w ramach, biorąc pod uwagę wszystko, co może zostać utworzone na potrzeby automatyzacji. Miałem nadzieję, że coś takiego:

git clone [email protected]:company/*.git

lub coś podobnego zadziałałoby, ale nie wygląda na to, aby ten symbol wieloznaczny był tam podobny.

Czy w Git jest sposób na sklonowanie, a następnie pobranie wszystkiego, zakładając, że ma się odpowiednie uprawnienia?

git github git-clone numb3rs1x
źródło
2
Dobre pytanie. A co powiesz na utrzymanie ich synchronizacji poprzez pull? Czy którakolwiek z odpowiedzi działa w przypadku pull?
nealmcb
Potrzebujemy rozwiązania w Pythonie, dla tych z nas, którzy nie są tak biegli w node lub ruby;) Albo github powinien to przeczytać i zlitować się nad nami i po prostu zapewnić prosty interfejs sieciowy do tego ...
nealmcb
Wypróbuj: github.com/wballard/git-friends
kenorb

Odpowiedzi:

53

Myślę, że nie można tego zrobić w ten sposób. Najlepszym rozwiązaniem jest znalezienie i przejrzenie listy repozytoriów organizacji za pomocą interfejsu API.

Spróbuj tego:

  • Utwórz token API, przechodząc do Ustawienia konta -> Aplikacje
  • Zadzwoń do: http://${GITHUB_BASE_URL}/api/v3/orgs/${ORG_NAME}/repos?access_token=${ACCESS_TOKEN}
  • Odpowiedzią będzie tablica obiektów JSON. Każdy obiekt będzie zawierał informacje o jednym z repozytoriów w ramach tej organizacji. Myślę, że w twoim przypadku będziesz szukał konkretnie ssh_urlnieruchomości.
  • Następnie git clonekażdy z tych ssh_urls.

To trochę dodatkowej pracy, ale GitHub musi mieć odpowiednie uwierzytelnianie.

Thomas Kelley
źródło
Utworzyłem token API i otrzymuję dane wyjściowe z wywołania, ale nie widzę niczego, co odnosi się do tego, co wiem o naszych repozytoriach, ani do ciągu „ssh_url”. Podejrzewam, że nie wykonałem połączenia poprawnie. curl -i https://github.com/api/v3/orgs/company/repos?access_token=<token>
numb3rs1x
Czy to konto GitHub Enterprise, czy github.com?
Thomas Kelley
1
Ach, źle cię zrozumiałem. Myślałem, że to konto Enterprise. Zamiast tego https://github.com/api/v3/spróbuj https://api.github.com/.
Thomas Kelley
1
Nie jestem pewien, jak jest skonfigurowana Twoja konkretna firma, ale jeśli jest to „użytkownik”, a nie „organizacja”, zamiast tego będziesz chciał użyć /users/${COMPANY}/reposścieżki /orgs/${COMPANY}/repos.
Thomas Kelley,
2
Na GitHub: Zamiast tego użyj nagłówka Authorization HTTP, ponieważ używanie access_tokenparametru zapytania jest przestarzałe. Jeśli ten token jest używany przez aplikację, nad którą nie masz kontroli, pamiętaj, że może przestać działać w wyniku tego wycofania.
BogeyMan
116

W systemie Windows i wszystkich systemach UNIX / LINUX , używając Git Bash lub innego terminala , zastąp YOURUSERNAMEswoją nazwą użytkownika i użyj:

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
  • Ustaw CNTX=usersi NAME=yourusername, aby pobrać wszystkie swoje repozytoria.
  • Ustaw CNTX=orgsi NAME=yourorgname, aby pobrać wszystkie repozytoria organizacji.

Maksymalny rozmiar strony to 100, więc musisz zadzwonić do tego kilka razy z odpowiednim numerem strony, aby uzyskać wszystkie swoje repozytoria (ustaw PAGEżądany numer strony, którą chcesz pobrać).

Oto skrypt powłoki, który wykonuje powyższe czynności: https://gist.github.com/erdincay/4f1d2e092c50e78ae1ffa39d13fa404e

Erdinc Ay
źródło
4
Czyste rozwiązanie bash, najprostsze. Dla twojej informacji, ten kod bash może być wykonany w prawie każdym środowisku * nix, Linuksie, Cygwin, Mingw i oczywiście Gitbash, który jest tak naprawdę emulacją terminala, jak inne.
m3nda
1
To nie działa w przypadku organizacji, więc nie odpowiada bezpośrednio na pytanie. Ta odpowiedź od Kenorb obsługuje organizacje i działa również dla maksymalnie 1000 repozytoriów - działała lepiej dla mnie.
RichVel
1
z uwierzytelnianiem: curl " api.github.com/$CNTX/$NAME/… " | grep -e 'git_url *' | cut -d \ "-f 4 | xargs -L1 git clone
Yannick Wurm
2
Zaktualizuj odpowiedź (luty-2019): zgodnie z GitHub API v3, Twoje curl powinno przejść do / orgs / ORGNAME / repos. Możesz także dołączyć link do API v3: developer.github.com/v3 Również w przypadku prywatnych repozytoriów musisz dodać curl -u "nazwa użytkownika", a następnie curl zapyta Cię raz o hasło. W przeciwnym razie działa świetnie!
:)
1
AKTUALIZACJA od Dimitry Hewkoplyas komentarz stackoverflow.com/questions/19576742/… . developer.github.com/v3 zwraca stan 301 podczas próby zwijania. użyj tego polecenia bash curl -u "{nazwa użytkownika}" " api.github.com/orgs {org} / repos? page = 1 & per_page = 100" | grep -o 'git @ [^ "] *' | xargs -L1 git clone działa w 100%
Tommy
45

Repozytoria organizacji

Aby sklonować wszystkie repozytoria z organizacji, wypróbuj następującą jednoliniową powłokę:

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

Repozytoria użytkowników

Klonowanie wszystkiego za pomocą adresów URL repozytorium Git:

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

Klonowanie wszystkiego za pomocą Clone 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

Oto przydatna funkcja powłoki, którą można dodać do plików startowych użytkownika (za pomocą 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
}

Prywatne repozytoria

Jeśli chcesz sklonować prywatne repozytoria, możesz dodać token autoryzacji w swoim nagłówku, na przykład:

-H 'Authorization: token <token>'

lub przekaż go w param ( ?access_token=TOKEN), na przykład:

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

Uwagi:

  • Aby pobrać tylko prywatne repozytoria, dodaj type=privatedo ciągu zapytania.
  • Innym sposobem jest użycie hubpo skonfigurowaniu klucza API.

Zobacz też:

Wskazówki :
- Aby zwiększyć szybkość, ustaw liczbę równoległych procesów, określając -Pparametr dla xargs( -P4= 4 procesy).
- Jeśli chcesz zwiększyć limity GitHub, spróbuj uwierzytelnić się, określając klucz API.
- Dodaj --recursiverekursję do zarejestrowanych modułów podrzędnych i zaktualizuj wszystkie zagnieżdżone moduły podrzędne.

kenorb
źródło
2
per_page = 1000 maxes out po 100
aehlke
20

Ta treść kończy zadanie w jednej linii w linii poleceń:

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"]} ]}'

Zastąp [your_org]nazwą swojej organizacji. I ustaw, per_pagejeśli to konieczne.

AKTUALIZACJA:

Jak wspomniał ATutorMe, maksymalny rozmiar strony to 100, zgodnie z dokumentacją GitHub .

Jeśli masz więcej niż 100 repozytoriów, musisz dodać pageparametr do swojego adresu URL i możesz uruchomić polecenie dla każdej strony.

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"]} ]}'

Uwaga: per_pageparametr domyślny to 30.

seancdavis
źródło
Masz jakiś pomysł, jak to się robi w przypadku prywatnych repozytoriów, do których masz dostęp?
MichaelGofron
drugi nie działa, ponieważ znak ampersand przechodzi do zadania w tle
slashdottir
Dodałem & access_token = <my_access_token> do adresu URL i działało idealnie
rmartinus
Drugi: strona = 1 (!)
Yannick Wurm
5

Przejdź do Ustawienia konta -> Aplikacja i utwórz klucz API
Następnie wstaw klucz API, adres URL instancji github i nazwę organizacji w poniższym skrypcie

#!/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"]} ]}'

Zapisz to w pliku, chmod u+xplik, a następnie uruchom go.

Dzięki Arnaud za kod rubinowy.

Cory Klein
źródło
5

Więc dodam też swoją odpowiedź. :) (stwierdziłem, że to proste)

Lista pobierania (użyłem firmy "magento"):

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

Użyj clone_urlzamiast ssh_urldostępu użycie HTTP.

Więc sklonujmy je wszystkie! :)

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

Jeśli zamierzasz pobrać repozytorium prywatne - po prostu dodaj parametr GET ?access_token=YOURTOKEN

Kirby
źródło
4

Znalazłem komentarz w sedno @seancdavis warunkiem jest bardzo pomocny, zwłaszcza, że jak oryginalny plakat, chciałem, aby zsynchronizować wszystkie repo dla szybkiego dostępu, jednak z których większość były prywatne.

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"]} ]}'

Zastąp [[NAZWA UŻYTKOWNIKA]] swoją nazwą użytkownika github, a [[ORGANIZACJA]] nazwą swojej organizacji Github. Dane wyjściowe (metadane repozytorium JSON) zostaną przekazane do prostego skryptu ruby:

# 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
Garren S
źródło
1
To rozwiązanie działało idealnie dla mnie. Właściwie wszystko, czego potrzebowałem, to sklonować wszystkie repozytoria moich kont osobistych na nową maszynę lokalną. Bardzo przydatne do konfigurowania nowej stacji roboczej. Uwaga: aby to zrobić, musiałem zmienić .../orgs/[[organization]]/repos...na .../users/[[username]]/repos.... Teraz mogę szybko zaimportować całą swoją pracę na różne komputery lokalne. DZIĘKI!
B. Bulpett
2

Ta jedna linijka Pythona zrobi to, czego potrzebujesz. To:

  • sprawdza github pod kątem dostępnych repozytoriów

  • dla każdego, wykonuje wywołanie systemowe 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'))]"
Evren Ozkan
źródło
2 
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
julianzhang
źródło
2
Dodaj wyjaśnienie do swojego rozwiązania. W ten sposób inne osoby z podobnymi problemami będą mogły łatwiej zrozumieć Twoje rozwiązanie!
Nander Speerstra
Szczegółem jest potrzeba podania numeru strony, na przykład ?page=2.
Bruno Wego
2

Proste rozwiązanie:

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
Antonio Feitosa
źródło
2

Wypróbowałem kilka powyższych poleceń i narzędzi, ale zdecydowałem, że są zbyt kłopotliwe, więc napisałem inne narzędzie wiersza poleceń, które to robi, o nazwie github-dl.

Aby go użyć (zakładając, że masz zainstalowany nodejs)

npx github-dl -d /tmp/test wires

Spowoduje to pobranie listy wszystkich repozytoriów z wiresi zapisanie informacji do testkatalogu, używając szczegółów autoryzacji (użytkownik / hasło), które podasz w CLI.

W szczegółach to

  1. Pyta o autoryzację (obsługuje 2FA)
  2. Pobiera listę repozytoriów dla użytkownika / organizacji za pośrednictwem interfejsu API Github
  3. Robi w tym celu paginację, więc obsługiwanych jest ponad 100 repozytoriów

W rzeczywistości nie klonuje repozytoriów, ale zamiast tego zapisuje .txtplik, do którego możesz przekazać, xargsaby wykonać klonowanie, na przykład:

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

Może jest to dla ciebie przydatne; to tylko kilka linijek JS, więc powinno być łatwe do dostosowania do twoich potrzeb

przewody
źródło
1

Do tego celu służy również bardzo przydatny moduł npm . Może nie tylko klonować, ale także ściągać (aby zaktualizować dane, które już masz).

Po prostu tworzysz konfigurację w ten sposób:

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

i gitall clonena przykład. Lubgitall pull

Vladislav Rastrusny
źródło
1

Jeśli ktoś szuka rozwiązania dla systemu Windows, oto mała funkcja w PowerShell, aby załatwić sprawę (może to być oneliner / alias, jeśli nie fakt, że potrzebuję go do pracy zarówno z proxy, jak i bez).

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() }
}
Andrzej Lichnerowicz
źródło
1

Tak więc, w praktyce, jeśli chcesz sklonować wszystkie repozytoria z organizacji, FOOktóra pasuje BAR, możesz użyć poniższego linijki poniżej, która wymaga narzędzi jq i typowych narzędzi CLI

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

Kolejny skrypt powłoki z komentarzami, który klonuje wszystkie repozytoria (publiczne i prywatne) od użytkownika:

#!/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
hlorand
źródło
1

Utwórz alias / func bash w swoim ~/.bashrc file

Rozwiązałem to dla mojego zespołu, tworząc alias / bash func w moim ~/.bashrc file

kroki

otwórz terminal lub powłokę Linuksa i otwórz ~/.bashrc file:

sudo nano ~/.bashrc

dodaj tę funkcję:

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
}

zapisz i zamknij plik ~ / .bashrc, a następnie zamknij terminal - musisz to zrobić, inaczej nowa funkcja nie zostanie zainicjalizowana:

otwórz nowy terminal i wypróbuj go:

CloneAll <your_github_org_name>

Przykład : jeśli Twój osobisty adres URL repozytorium github nazywa się https://github.com/awesome-async, polecenie byłoby takie

CloneAll awesome-async

Ważny

per_page=200pod koniec pierwszej zmiennej ORG_URLustawia liczbę transakcji repo, które zostaną sklonowane, więc zwrócić szczególną uwagę, że:

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

Mam nadzieję że to pomoże! :)

Flavio
źródło
Wydaje się, że max. wartość per_page to 100 ... dla dużych organizacji dodano numer strony jako drugi parametr i działa idealnie na moje potrzeby...repos?page=${2}&per_page=100";
sv3n
0

Możesz uzyskać listę repozytoriów, używając, curla następnie iterując po tej liście za pomocą pętli bash:

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
Sriram Mageswaran
źródło
0

Aby sklonować tylko prywatne repozytoria, mając klucz dostępu i mając zainstalowany moduł Python 3 i request:

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;
ubugnu
źródło
0

Rozwiązanie w języku Python3, które obejmuje pełne stronicowanie za pomocą Linknagłówka.

Wymagania wstępne:

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])

Następnie możesz użyć xargslub równolegle i:cat repolist | parallel -I% hub clone %

Jose Alban
źródło
0

Jeśli masz listę repozytoriów na liście takiej jak ta, to działa ten skrypt powłoki:

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

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

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

do

   echo $user"$i"

   git clone $user"$i"

done
Kasthuri Shravankumar
źródło
jeśli są jakieś prywatne repozytoria, możesz zaktualizować „user” w ten sposób: user = „ user:
hasł[email protected]/user
0

Stworzyłem przykładowy skrypt wsadowy. Możesz pobrać wszystkie repozytoria prywatne / publiczne ze strony github.com. Po pobraniu repozytorium jest ono automatycznie konwertowane na plik zip.

@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 ..
)

Uwaga: plik files.txt powinien zawierać tylko nazwy repozytoriów, takie jak:

repository1
repository2
olyanren
źródło
0

Aktualizacja z 19 maja

użyj tego polecenia bash dla organizacji (w tym prywatne repozytorium)

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

Przeważające tutaj odpowiedzi nie uwzględniają tego, że Github API zwróci maksymalnie 100 repozytoriów, niezależnie od tego, co możesz określić w per_page. Jeśli klonujesz organizację Github z ponad 100 repozytoriami, będziesz musiał skorzystać z linków stronicowania w odpowiedzi API.

Napisałem narzędzie CLI, aby to zrobić :

clone-github-org -o myorg

Spowoduje to sklonowanie wszystkich repozytoriów w myorgorganizacji do bieżącego katalogu roboczego.

Czad
źródło
0

W przypadku organizacji, do których masz dostęp za pomocą prywatnych repozytoriów:

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”]} ]}'

Używa html_url, więc access_tokenpo wyświetleniu monitu nie musisz po prostu wpisywać hasła github.

Flavio
źródło
1
Uwierzytelnianie podstawowe przy użyciu hasła do interfejsu API jest przestarzałe i wkrótce przestanie działać. Odwiedź stronę [deprecating-password-auth] ( developer.github.com/changes/… ), aby uzyskać więcej informacji na temat sugerowanych obejść i dat usunięcia.
BogeyMan
0

Sklonuj wszystkie swoje repozytoria, które nie są forkami:

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

Sklonuj swoje istoty:

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

To jqpolecenie jest złożone, ponieważ nazwa repozytorium streszczeń jest skrótami, więc polecenie łączy wszystkie nazwy plików, aby były nazwą repozytorium

Możesz dowolnie filtrować JSON, używając jq

zainstalować: sudo apt-get install jq

W powyższym przykładzie odfiltrowałem forki, używając tego: curl ... | jq -r 'map(select(.fork == false))' ...- przydatne, gdy nie klonujesz repozytoriów, gdy wykonałeś przypadkowe żądania ściągnięcia

jq obsługuje bardzo zaawansowane funkcje. man jqjest twoim przyjacielem

Możesz uwierzytelnić się, curl -u "username" ... aby uzyskać dostęp do prywatnych repozytoriów

URL-e API Guthuba

  • Twoje repozytoria (wymaga uwierzytelnienia): https://api.github.com/user/repos\?page\=1\&per_page\=100
  • Dowolny użytkownik: https://api.github.com/users/other_username/repos\?page\=1\&per_page\=100
  • Organizacje: https://api.github.com/orgs/orgname/repos\?page\=1\&per_page\=100

Dokumenty API Github dla repozytoriów

Madacol
źródło
0 
"""
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']}...")
Martin Thoma
źródło
0

Aby sklonować wszystkie swoje prywatne i publiczne repozytoria, po prostu wygeneruj nowy token dostępu z dostępem do repozytoriów i użyj tego:

(zastąp własnym tokenem dostępu i nazwą użytkownika)

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

Spowoduje to sklonowanie wszystkich repozytoriów w bieżącym folderze

To jest mały program bash, możesz go po prostu wkleić do terminala i nacisnąć Enter

Basel Akasha
źródło
0

Możesz użyć narzędzia takiego jak GitHub Archive które pozwala klonować / pobierać publiczne i prywatne repozytoria osobiste, repozytoria organizacji i streszczenia za pomocą jednego prostego narzędzia.

Jeśli chodzi o automatyzację, możesz skonfigurować archiwum GitHub, aby działało na przykład raz dziennie lub raz w tygodniu, a pominie te, które są sklonowane i pobierze nowe zmiany od ostatniego uruchomienia wszystkich innych.

Źródło: https://github.com/Justintime50/github-archive

Justin Hammond
źródło