.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 -x) set -x; shift;;
   8 esac
   9
  10 case $1 in
  11 ""|-*) ;;
  12 l)
  13         cmd=list
  14         shift
  15         ;;
  16 s)
  17         cmd=sync
  18         shift
  19         ;;
  20 rb-all)
  21         cmd=rebase
  22         shift
  23         set -- all "$@"
  24         ;;
  25 *)
  26         cmd=$1
  27         shift
  28         acmd=$(git config --get "alias.${cmd}" | sed 's: -.*::')
  29         ;;
  30 esac
  31
  32 mj_init() {
  33         pipe=$(mktemp)
  34         rm -f "${pipe}"
  35         mkfifo "${pipe}"
  36         exec {ctlfd}<>"${pipe}"
  37         rm -f "${pipe}"
  38         jobs=0
  39         jobs_max=${1:-$(getconf _NPROCESSORS_ONLN)}
  40 }
  41 _mj_child() { echo ${BASHPID} $? >&${ctlfd} ; }
  42 mj_child() {
  43         (
  44         "$@"
  45         _mj_child
  46         ) &
  47         mj_post_child
  48 }
  49 mj_post_child() {
  50         : $(( ++jobs ))
  51         if [[ ${jobs} -eq ${jobs_max} ]] ; then
  52                 read -r -u ${ctlfd} pid ret
  53                 : $(( --jobs ))
  54         fi
  55 }
  56 mj_finish() {
  57         wait
  58 }
  59
  60 repo_root() {
  61         local root=${PWD}
  62         while [[ ! -d ${root}/.repo && ${root:-/} != "/" ]] ; do
  63                 root=${root%/*}
  64         done
  65         echo "${root}"
  66 }
  67
  68 process_reviewers() {
  69         local r arr=()
  70         for r in ${*//,/ } ; do
  71                 case ${r} in
  72                 *OWNERS)
  73                         local owners=$(
  74                                 awk -F'@' '
  75                                         ($2 == "chromium.org" || $2 == "google.com") {list = list "," $1}
  76                                         END {print substr(list, 2)}
  77                                 ' "${r}"
  78                         )
  79                         if [[ -z ${owners} ]] ; then
  80                                 err "cannot find OWNERS list"
  81                         else
  82                                 echo "Auto setting reviewers to: ${owners}"
  83                         fi
  84                         arr+=( ${owners} )
  85                         ;;
  86                 *)
  87                         arr+=( "${r}" )
  88                         ;;
  89                 esac
  90         done
  91         reviewers=$(printf '%s,' "${arr[@]}")
  92         reviewers=${reviewers%,}
  93 }
  94
  95 find_repo() {
  96         # Diff projects have diff versions of repo.  Find a compatible one.
  97         local root=$(repo_root)
  98
  99         # Use the manifest repo URL.
 100         local manifest_dir="${root}/.repo/manifests.git"
 101         local d
 102
 103         # Default to the local repo if it's there.
 104         local search=(
 105                 "${root}/.repo/repo"
 106         )
 107
 108         case $(g --git-dir="${manifest_dir}" config remote.origin.url) in
 109         *android*)
 110                 search+=(
 111                         /usr/local/src/repo
 112                         ~/src/repo
 113                 )
 114                 ;;
 115         *chromium*|*chrome*)
 116                 search+=(
 117                         ~/depot_tools
 118                         ~/chromiumos/depot_tools
 119                         /usr/local/src/depot_tools
 120                         ~/src/depot_tools
 121                 )
 122                 ;;
 123         esac
 124         for d in "${search[@]}" ; do
 125                 if [[ -x ${d}/repo ]] ; then
 126                         echo "${d}"/repo
 127                         return
 128                 fi
 129         done
 130
 131         # Fallback: use $PATH.
 132         type -P repo
 133 }
 134
 135 case ${acmd:-${cmd}} in
 136 rebase)
 137         if [[ $1 == "all" ]] ; then
 138                 shift
 139                 if [[ $# -eq 0 ]] ; then
 140                         eval $(bash-colors --env | sed 's:^:export :')
 141                         root=$(repo_root)
 142                         mj_init
 143                         while read -a line ; do
 144                                 dir=${line[0]}
 145                                 proj=${line[2]}
 146                                 if ! cd "${root}/${dir}" ; then
 147                                         echo "bad ${proj}"
 148                                         continue
 149                                 fi
 150                                 (
 151                                 out=$(env _proj=${proj} r rb all . 2>&1)
 152                                 if [[ -n ${out} ]] ; then
 153                                         while read line ; do
 154                                                 case ${line} in
 155                                                 "Fast-forwarded "*) ;;
 156                                                 "# "*)
 157                                                         line="${line#[#] }"
 158                                                         printf '%s### %s%-40s%s: %s\n' \
 159                                                                 "${BRACKET}" "${GOOD}" "${line%%:*}" "${NORMAL}" "${line#*:}"
 160                                                         ;;
 161                                                 *)
 162                                                         printf '%s### %s%-40s%s: ERROR: %s\n' \
 163                                                                 "${BRACKET}" "${BAD}" "${dir}" "${NORMAL}" "${line}"
 164                                                         ;;
 165                                                 esac
 166                                         done < <(echo "${out}")
 167                                 fi
 168                                 _mj_child
 169                                 ) &
 170                                 mj_post_child
 171                         done < <(r l)
 172                         mj_finish
 173                         exit 0
 174                         #exec r forall -p -c 'r rb all .' </dev/null
 175                 fi
 176
 177                 branches=$(g b | awk '
 178                         {
 179                                 if ($0 ~ "^[*] *[(]no branch[)]") {
 180                                         next
 181                                 } else if ($0 ~ "^[*] *[(](HEAD )?detached (from|at) ") {
 182                                         next
 183                                 } else if ($1 == "*") {
 184                                         b = $2
 185                                 } else {
 186                                         list = list $1 " "
 187                                 }
 188                         }
 189                         END { print list b }')
 190                 [[ -z ${branches} ]] && exit 0
 191
 192                 [[ -z ${GOOD} ]] && eval $(bash-colors --env)
 193                 #echo "${GOOD}### ${PWD}${NORMAL}"
 194                 # Skip if rebase is in progress.
 195                 if [[ -e .git/rebase-merge/interactive ]] ; then
 196                         echo -e "# ${_proj}: ${WARN}skipping due to active rebase${NORMAL}"
 197                         exit 1
 198                 fi
 199                 for b in ${branches} ; do
 200                         #echo " ${HILITE}### $b${NORMAL}"
 201                         g co -q $b || exit 1
 202                         if ! r rb -q "$@" ; then
 203                                 g rb-a
 204                         fi
 205                 done
 206                 exit 0
 207         fi
 208         ;;
 209 clean)
 210         root=$(repo_root)
 211         cd "${root}" || exit 1
 212         mj_init
 213         while read -a line ; do
 214                 dir=${line[0]}
 215                 proj=${line[2]}
 216                 cd "${root}/${dir}"
 217                 (
 218                 out=$(g clean "$@" 2>&1)
 219                 if [[ -n ${out} ]] ; then
 220                         echo "### ${proj}"
 221                         echo "${out}"
 222                 fi
 223                 _mj_child
 224                 ) &
 225                 mj_post_child
 226         done < <(r l)
 227         mj_finish
 228         exit
 229         ;;
 230 sb)
 231         sb_cmd=$1
 232         case ${sb_cmd} in
 233         pull) ;;
 234         push) ;;
 235         f|fetch) sb_cmd="fetch" ;;
 236         *) err "unknown sandbox command: $1"
 237         esac
 238
 239         sync_branch="v"
 240
 241         root=$(repo_root)
 242         cd "${root}" || exit 1
 243
 244         if [[ ! -e .repo/sandbox-url ]] ; then
 245                 err "Please configure remote url base in ${root}/.repo/sandbox-url"
 246         fi
 247         remote=$(<.repo/sandbox-url) || exit 1
 248
 249         echo "pushing projects from ${root}"
 250
 251         # ssh servers do not like it when you hammer them :)
 252         #       Received disconnect from 74.125.248.80: 7: Too many concurrent connections
 253         #       fatal: The remote end hung up unexpectedly
 254         mj_init 16
 255
 256         rlist=$(r l)
 257         tcnt=$(echo "${rlist}" | wc -l)
 258         cnt=1
 259         while read line ; do
 260                 line=( ${line} )
 261                 path=${line[0]}
 262                 export GIT_DIR=${path}/.git
 263                 proj=${line[2]}
 264                 printf '### (%*i/%i %3i%%) %s\n' \
 265                         ${#tcnt} $((cnt++)) ${tcnt} $(( cnt * 100 / tcnt )) ${proj}
 266                 src="${sync_branch}"
 267                 case ${sb_cmd} in
 268                 push)
 269                         g l -1 ${src} >& /dev/null || src=
 270                         mj_child g push --force ${remote}/${proj} ${src}:refs/sandbox/${USER}/${sync_branch} >/dev/null
 271                         ;;
 272                 pull)
 273                         ;;
 274                 fetch)
 275                         mj_child g fetch ${remote}/${proj} refs/sandbox/${USER}/${sync_branch}:refs/remotes/sb/${sync_branch} >/dev/null
 276                         ;;
 277                 esac
 278         done < <(echo "${rlist}")
 279         mj_finish
 280
 281         exit 0
 282         ;;
 283 g-push)
 284         # For the times when repo is being stupid, push directly to gerrit myself.
 285         if ! branch=$(g symbolic-ref -q HEAD) ; then
 286                 err "could not figure out active branch"
 287         fi
 288         branch=${branch#refs/heads/}
 289         if ! remote_branch=$(g cfg --get "branch.${branch}.merge") ; then
 290                 echo "could not figure out remote branch; using ${branch}"
 291                 remote_branch=${branch}
 292         fi
 293         if ! remote=$(g cfg --get "branch.${branch}.remote") ; then
 294                 for remote in cros-internal cros origin ; do
 295                          g cfg --get "remote.${remote}.url" >/dev/null && break
 296                 done
 297         fi
 298         review=$(g cfg --get "remote.${remote}.review")
 299         remote_branch=${remote_branch#refs/heads/}
 300
 301         git_args=()
 302         reviewers=""
 303         while [[ $# -gt 0 ]] ; do
 304                 case $1 in
 305                 --re)
 306                         process_reviewers "$2"
 307                         shift
 308                         ;;
 309                 -n|--dry-run|--draft)
 310                         git_args+=( $1 )
 311                         ;;
 312                 *)
 313                         err "unknown option: $1"
 314                         ;;
 315                 esac
 316                 shift
 317         done
 318
 319         ref_spec="${branch}:refs/for/${remote_branch}"
 320         if [[ -n ${reviewers} ]] ; then
 321                 reviewers=( ${reviewers//,/ } )
 322                 if [[ ${review} != ssh://* ]] ; then
 323                         gob_args=$(printf 'r=%s,' "${reviewers[@]}")
 324                         ref_spec+="%${gob_args%,}"
 325                 else
 326                         git_args+=( "--receive-pack=git receive-pack ${reviewers[*]/#/--reviewer=}" )
 327                 fi
 328         fi
 329
 330         vr git push "${git_args[@]}" ${remote} ${ref_spec} && exit
 331         err "could not figure out remote to push to"
 332         ;;
 333 sync)
 334         set -- -j16 -c "$@"
 335         ;;
 336 upload)
 337         args=()
 338         while [[ $# -gt 0 ]] ; do
 339                 case $1 in
 340                 --re)
 341                         process_reviewers "$2"
 342                         args+=( --re "${reviewers}" )
 343                         shift 2
 344                         continue
 345                         ;;
 346                 esac
 347                 args+=( "$1" )
 348                 shift
 349         done
 350         set -- "${args[@]}"
 351         ;;
 352 email)
 353         email=${1:-${USER}@chromium.org}
 354
 355         root=$(repo_root)
 356         git --git-dir="${root}/.repo/manifests.git" cfg user.email "${email}"
 357         git --git-dir="${root}/.repo/repo/.git" cfg user.email "${email}"
 358
 359         cmd='forall'
 360         set -- -c "git cfg user.email '${email}'"
 361         ;;
 362 esac
 363
 364 exec python2 $(find_repo) ${acmd:-${cmd}} "$@"