.bin/r

   1 #!/bin/bash
   2 g() { git "$@"; }
   3 err() { printf '%b\n' "$*" 1>&2; exit 1; }
   4 vr() { echo "$@"; "$@"; }
   5
   6 case $1 in
   7 ""|-*) ;;
   8 l)
   9         cmd=list
  10         shift
  11         ;;
  12 s)
  13         cmd=sync
  14         shift
  15         ;;
  16 *)
  17         cmd=$1
  18         shift
  19         acmd=$(git config --get "alias.${cmd}" | sed 's: -.*::')
  20         ;;
  21 esac
  22
  23 mj_init() {
  24         pipe=$(mktemp)
  25         rm -f "${pipe}"
  26         mkfifo "${pipe}"
  27         exec {ctlfd}<>"${pipe}"
  28         rm -f "${pipe}"
  29         jobs=0
  30         jobs_max=${1:-$(getconf _NPROCESSORS_ONLN)}
  31 }
  32 _mj_child() { echo ${BASHPID} $? >&${ctlfd} ; }
  33 mj_child() {
  34         (
  35         "$@"
  36         _mj_child
  37         ) &
  38         mj_post_child
  39 }
  40 mj_post_child() {
  41         : $(( ++jobs ))
  42         if [[ ${jobs} -eq ${jobs_max} ]] ; then
  43                 read -r -u ${ctlfd} pid ret
  44                 : $(( --jobs ))
  45         fi
  46 }
  47 mj_finish() {
  48         wait
  49 }
  50
  51 repo_root() {
  52         local root=${PWD}
  53         while [[ ! -d ${root}/.repo && ${root} != "/" ]] ; do
  54                 root=${root%/*}
  55         done
  56         echo "${root}"
  57 }
  58
  59 case ${acmd:-${cmd}} in
  60 rebase)
  61         if [[ $1 == "all" ]] ; then
  62                 shift
  63                 if [[ $# -eq 0 ]] ; then
  64                         eval $(bash-colors --env | sed 's:^:export :')
  65                         root=$(repo_root)
  66                         mj_init
  67                         while read -a line ; do
  68                                 dir=${line[0]}
  69                                 proj=${line[2]}
  70                                 cd "${root}/${dir}"
  71                                 (
  72                                 out=$(env _proj=${proj} r rb all . 2>&1)
  73                                 if [[ -n ${out} ]] ; then
  74                                         while read line ; do
  75                                                 if [[ ${line} == "# "* ]] ; then
  76                                                         line="${line#[#] }"
  77                                                         printf '%s### %s%-40s%s: %s\n' \
  78                                                                 "${BRACKET}" "${GOOD}" "${line%%:*}" "${NORMAL}" "${line#*:}"
  79                                                 else
  80                                                         echo "${line}"
  81                                                 fi
  82                                         done < <(echo "${out}")
  83                                 fi
  84                                 _mj_child
  85                                 ) &
  86                                 mj_post_child
  87                         done < <(r l)
  88                         mj_finish
  89                         exit 0
  90                         #exec r forall -p -c 'r rb all .' </dev/null
  91                 fi
  92
  93                 branches=$(g b | awk '
  94                         {
  95                                 if ($0 ~ "^[*] *[(]no branch[)]") {
  96                                         next
  97                                 } else if ($0 ~ "^[*] *[(]detached from ") {
  98                                         next
  99                                 } else if ($1 == "*") {
 100                                         b = $2
 101                                 } else {
 102                                         list = list $1 " "
 103                                 }
 104                         }
 105                         END { print list b }')
 106                 [[ -z ${branches} ]] && exit 0
 107
 108                 [[ -z ${GOOD} ]] && eval $(bash-colors --env)
 109                 #echo "${GOOD}### ${PWD}${NORMAL}"
 110                 # Skip if rebase is in progress.
 111                 if [[ -e .git/rebase-merge/interactive ]] ; then
 112                         echo -e "# ${_proj}: ${WARN}skipping due to active rebase${NORMAL}"
 113                         exit 1
 114                 fi
 115                 for b in ${branches} ; do
 116                         #echo " ${HILITE}### $b${NORMAL}"
 117                         g co -q $b || exit 1
 118                         if ! r rb -q "$@" ; then
 119                                 g rb-a
 120                         fi
 121                 done
 122                 exit 0
 123         fi
 124         ;;
 125 clean)
 126         root=$(repo_root)
 127         cd "${root}" || exit 1
 128         mj_init
 129         while read -a line ; do
 130                 dir=${line[0]}
 131                 proj=${line[2]}
 132                 cd "${root}/${dir}"
 133                 (
 134                 out=$(g clean "$@" 2>&1)
 135                 if [[ -n ${out} ]] ; then
 136                         echo "### ${proj}"
 137                         echo "${out}"
 138                 fi
 139                 _mj_child
 140                 ) &
 141                 mj_post_child
 142         done < <(r l)
 143         mj_finish
 144         exit
 145         ;;
 146 sb-push)
 147         sync_branch="v"
 148
 149         root=$(repo_root)
 150         cd "${root}" || exit 1
 151
 152         if [[ ! -e .repo/sandbox-url ]] ; then
 153                 err "Please configure remote url base in ${root}/.repo/sandbox-url"
 154         fi
 155         remote=$(<.repo/sandbox-url) || exit 1
 156
 157         echo "pushing projects from ${root}"
 158
 159         # ssh servers do not like it when you hammer them :)
 160         #       Received disconnect from 74.125.248.80: 7: Too many concurrent connections
 161         #       fatal: The remote end hung up unexpectedly
 162         mj_init 16
 163
 164         rlist=$(r l)
 165         tcnt=$(echo "${rlist}" | wc -l)
 166         cnt=1
 167         while read line ; do
 168                 line=( ${line} )
 169                 path=${line[0]}
 170                 export GIT_DIR=${path}/.git
 171                 proj=${line[2]}
 172                 printf '### (%*i/%i %3i%%) %s\n' \
 173                         ${#tcnt} $((cnt++)) ${tcnt} $(( cnt * 100 / tcnt )) ${proj}
 174                 src="${sync_branch}"
 175                 g l -1 ${src} >& /dev/null || src=
 176                 mj_child g push --force ${remote}/${proj} ${src}:refs/sandbox/${USER}/${sync_branch} >/dev/null
 177         done < <(echo "${rlist}")
 178         mj_finish
 179
 180         exit 0
 181         ;;
 182 g-push)
 183         # For the times when repo is being stupid, push directly to gerrit myself.
 184         if ! branch=$(g symbolic-ref -q HEAD) ; then
 185                 err "could not figure out active branch"
 186         fi
 187         branch=${branch#refs/heads/}
 188         if ! remote_branch=$(g cfg --get "branch.${branch}.merge") ; then
 189                 err "could not figure out remote branch"
 190         fi
 191         if ! remote=$(g cfg --get "branch.${branch}.remote") ; then
 192                 for remote in cros-internal cros origin ; do
 193                          g cfg --get "remote.${remote}.url" >/dev/null && break
 194                 done
 195         fi
 196         remote_branch=${remote_branch#refs/heads/}
 197
 198         git_args=()
 199         reviewers=""
 200         while [[ $# -gt 0 ]] ; do
 201                 case $1 in
 202                 --re)
 203                         reviewers=$2
 204                         shift
 205                         ;;
 206                 -n|--dry-run)
 207                         git_args+=( $1 )
 208                         ;;
 209                 *)
 210                         err "unknown option: $1"
 211                         ;;
 212                 esac
 213                 shift
 214         done
 215
 216         if [[ -n ${reviewers} ]] ; then
 217                 reviewers=( ${reviewers//,/ } )
 218                 git_args+=( "--receive-pack=git receive-pack ${reviewers[*]/#/--reviewer=}" )
 219         fi
 220
 221         vr git push "${git_args[@]}" ${remote} ${branch}:refs/for/${remote_branch} && exit
 222         err "could not figure out remote to push to"
 223         ;;
 224 sync)
 225         set -- -j16 -c "$@"
 226         ;;
 227 upload)
 228         args=()
 229         while [[ $# -gt 0 ]] ; do
 230                 case $1 in
 231                 --re)
 232                         if [[ $2 == *"OWNERS" ]] ; then
 233                                 owners=$(awk -F'@' '{list = list "," $1} END {print substr(list, 2)}' "$2")
 234                                 if [[ -z ${owners} ]] ; then
 235                                         err "cannot find OWNERS list"
 236                                 else
 237                                         echo "Auto setting reviewers to: ${owners}"
 238                                 fi
 239                                 args+=( --re "${owners}" )
 240                                 shift 2
 241                                 continue
 242                         fi
 243                         ;;
 244                 esac
 245                 args+=( "$1" )
 246                 shift
 247         done
 248         set -- "${args[@]}"
 249         ;;
 250 email)
 251         email=${1:-${USER}@chromium.org}
 252         cmd='forall'
 253         set -- -c "git cfg user.email ${email}"
 254         ;;
 255 esac
 256
 257 exec repo ${acmd:-${cmd}} "$@"