#!/bin/bash

# Build stable versions of all packages with current scripts.

# This gets run in the aboriginal top directory.

proc pull_repo
{
  # Clone working copy

  rm -rf "packages/alt-$1-0.tar.bz2" build/packages/alt-$1
  mkdir -p build/packages/alt-$1
  pushd build/packages/alt-$1 &&
  ln -s ../../../repos/$1/.git .git &&
  git checkout -f master &&
  git pull
  popd
}

# Expire snapshots directory

global SNAPSHOTS := $[find snapshots -mindepth 1 -maxdepth 1 -type d]
global COUNT := $( $(echo "$SNAPSHOTS" | wc -l) - 30 )
if test $COUNT -gt 0
{
  # Delete appropriate number of oldest entries, then dead symlinks.
  rm -rf $[ echo $SNAPSHOTS | sort | head -n $COUNT]
  rm -rf $[find -L snapshots -type l]
}

echo === Begin cron job

# Start a new snapshot

export SNAPSHOT_DATE=$[date +"%Y-%m-%d]
mkdir -p snapshots/$SNAPSHOT_DATE/base &&
rm snapshots/latest &&
ln -sf $SNAPSHOT_DATE snapshots/latest || exit 1

# build base repo

proc build_snapshot
{
  if test -z $USE_ALT
  {
    global SNAPNAME := 'base'
  } else {
    pull_repo $USE_ALT
    global SNAPNAME := $USE_ALT
  }

  echo === Building snapshot $SNAPNAME

  test $USE_ALT == linux &&
    more/for-each-arch.sh 'more/migrate-kernel.sh $TARGET'

  # Update manifest

  ./download.sh

  # If it's unchanged, just hardlink the previous binaries instead of rebuilding

  if cmp -s snapshots/latest/$SNAPNAME/MANIFEST packages/MANIFEST
  {
    cp -rl snapshots/latest/$SNAPNAME/* snapshots/$SNAPSHOT_DATE/$SNAPNAME
    return
  }

  # Build it

  nice -n 20 more/buildall.sh
  rm build/simple-cross-compiler-*.tar.bz2
  mv build/*.tar.bz2 build/logs build/MANIFEST snapshots/$SNAPSHOT_DATE/$SNAPNAME
}

build_snapshot base

echo === Building QEMU

# build qemu-git

global QPATH := ''""
global CPUS := $[echo /sys/devices/system/cpu/cpu[0-9]* | wc -w]
pull_repo qemu
pushd build/packages/alt-qemu
./configure --disable-werror &&
nice -n 20 make -j $CPUS !2 > !1 | tee build/logs/alt-qemu.txt &&
global QPATH := $[for i in [*-softmmu]{ echo -n $[pwd]/$i:; }]
popd

# test all with qemu-git

test -z $QPATH ||
  env PATH="$QPATH:$PATH" more/for-each-target.sh \
    'more/smoketest.sh $TARGET | tee snapshots/$SNAPSHOT_DATE/base/logs/newqemu-smoketest-$TARGET.txt'

#USE_ALT=linux build_snapshot
#USE_ALT=uClibc build_snapshot
#USE_ALT=busybox build_snapshot
(CommandList
  children: [
    (FuncDef
      name: pull_repo
      body: 
        (BraceGroup
          children: [
            (C {(rm)} {(-rf)} {(DQ (packages/alt-) ($ VSub_Number "$1") (-0.tar.bz2))} 
              {(build/packages/alt-) ($ VSub_Number "$1")}
            )
            (C {(mkdir)} {(-p)} {(build/packages/alt-) ($ VSub_Number "$1")})
            (AndOr
              children: [
                (C {(pushd)} {(build/packages/alt-) ($ VSub_Number "$1")})
                (AndOr
                  children: [
                    (C {(ln)} {(-s)} {(../../../repos/) ($ VSub_Number "$1") (/.git)} {(.git)})
                    (AndOr
                      children: [(C {(git)} {(checkout)} {(-f)} {(master)}) (C {(git)} {(pull)})]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (C {(popd)})
          ]
          spids: [16]
        )
      spids: [12 15]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SNAPSHOTS)
          op: Equal
          rhs: 
            {
              (DQ 
                (CommandSubPart
                  command_list: 
                    (CommandList
                      children: [
                        (C {(find)} {(snapshots)} {(-mindepth)} {(1)} {(-maxdepth)} {(1)} {(-type)} {(d)})
                      ]
                    )
                  left_token: <Left_CommandSub "$(">
                  spids: [94 110]
                )
              )
            }
          spids: [92]
        )
      ]
      spids: [92]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:COUNT)
          op: Equal
          rhs: 
            {
              (ArithSubPart
                anode: 
                  (ArithBinary
                    op_id: Arith_Minus
                    left: 
                      (ArithWord
                        w: 
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (Pipeline
                                      children: [
                                        (C {(echo)} {(DQ ($ VSub_Name "$SNAPSHOTS"))})
                                        (C {(wc)} {(-l)})
                                      ]
                                      negated: False
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [116 128]
                            )
                          }
                      )
                    right: (ArithWord w:{(Lit_Digits 30)})
                  )
                spids: [114 135]
              )
            }
          spids: [113]
        )
      ]
      spids: [113]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(Lit_Other "[")} {(DQ ($ VSub_Name "$COUNT"))} {(-gt)} {(0)} {(Lit_Other "]")})]
          action: [
            (C {(rm)} {(-rf)} 
              {
                (CommandSubPart
                  command_list: 
                    (CommandList
                      children: [
                        (Pipeline
                          children: [
                            (C {(echo)} {(DQ ($ VSub_Name "$SNAPSHOTS"))})
                            (C {(sort)})
                            (C {(head)} {(-n)} {($ VSub_Name "$COUNT")})
                          ]
                          negated: False
                        )
                      ]
                    )
                  left_token: <Left_CommandSub "$(">
                  spids: [162 182]
                )
              }
            )
            (C {(rm)} {(-rf)} 
              {
                (CommandSubPart
                  command_list: 
                    (CommandList
                      children: [(C {(find)} {(-L)} {(snapshots)} {(-type)} {(l)})]
                    )
                  left_token: <Left_CommandSub "$(">
                  spids: [189 199]
                )
              }
            )
          ]
          spids: [-1 151]
        )
      ]
      spids: [-1 201]
    )
    (C {(echo)} {(Lit_Other "=") (Lit_Other "=") (Lit_Other "=")} {(Begin)} {(cron)} {(job)})
    (C {(export)} 
      {(Lit_VarLike "SNAPSHOT_DATE=") 
        (CommandSubPart
          command_list: (CommandList children:[(C {(date)} {(Lit_Other "+") (DQ ("%Y-%m-%d"))})])
          left_token: <Left_CommandSub "$(">
          spids: [224 231]
        )
      }
    )
    (AndOr
      children: [
        (C {(mkdir)} {(-p)} {(snapshots/) ($ VSub_Name "$SNAPSHOT_DATE") (/base)})
        (AndOr
          children: [
            (C {(rm)} {(snapshots/latest)})
            (AndOr
              children: [
                (C {(ln)} {(-sf)} {($ VSub_Name "$SNAPSHOT_DATE")} {(snapshots/latest)})
                (C {(exit)} {(1)})
              ]
              op_id: Op_DPipe
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (FuncDef
      name: build_snapshot
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$USE_ALT"))} {(Lit_Other "]")})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:SNAPNAME)
                          op: Equal
                          rhs: {(base)}
                          spids: [291]
                        )
                      ]
                      spids: [291]
                    )
                  ]
                  spids: [-1 288]
                )
              ]
              else_action: [
                (C {(pull_repo)} {($ VSub_Name "$USE_ALT")})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:SNAPNAME)
                      op: Equal
                      rhs: {($ VSub_Name "$USE_ALT")}
                      spids: [303]
                    )
                  ]
                  spids: [303]
                )
              ]
              spids: [295 307]
            )
            (C {(echo)} {(Lit_Other "=") (Lit_Other "=") (Lit_Other "=")} {(Building)} {(snapshot)} 
              {($ VSub_Name "$SNAPNAME")}
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$USE_ALT"))} {(Lit_Other "=") (Lit_Other "=")} 
                  {(linux)} {(Lit_Other "]")}
                )
                (C {(more/for-each-arch.sh)} {(SQ <"more/migrate-kernel.sh $TARGET">)})
              ]
              op_id: Op_DAmp
            )
            (C {(./download.sh)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(cmp)} {(-s)} {(snapshots/latest/) ($ VSub_Name "$SNAPNAME") (/MANIFEST)} 
                      {(packages/MANIFEST)}
                    )
                  ]
                  action: [
                    (C {(cp)} {(-rl)} 
                      {(snapshots/latest/) ($ VSub_Name "$SNAPNAME") (/) (Lit_Other "*")} {(snapshots/) ($ VSub_Name "$SNAPSHOT_DATE") (/) ($ VSub_Name "$SNAPNAME")}
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [-1 376]
                )
              ]
              spids: [-1 397]
            )
            (C {(nice)} {(-n)} {(20)} {(more/buildall.sh)})
            (C {(rm)} {(build/simple-cross-compiler-) (Lit_Other "*") (.tar.bz2)})
            (C {(mv)} {(build/) (Lit_Other "*") (.tar.bz2)} {(build/logs)} {(build/MANIFEST)} 
              {(snapshots/) ($ VSub_Name "$SNAPSHOT_DATE") (/) ($ VSub_Name "$SNAPNAME")}
            )
          ]
          spids: [272]
        )
      spids: [268 271]
    )
    (C {(build_snapshot)} {(base)})
    (C {(echo)} {(Lit_Other "=") (Lit_Other "=") (Lit_Other "=")} {(Building)} {(QEMU)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:QPATH) op:Equal rhs:{(DQ )} spids:[460])]
      spids: [460]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CPUS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} 
                            {(/sys/devices/system/cpu/cpu) (Lit_Other "[") (0-9) (Lit_Other "]") 
                              (Lit_Other "*")
                            }
                          )
                          (C {(wc)} {(-w)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [465 479]
              )
            }
          spids: [464]
        )
      ]
      spids: [464]
    )
    (C {(pull_repo)} {(qemu)})
    (C {(pushd)} {(build/packages/alt-qemu)})
    (AndOr
      children: [
        (C {(./configure)} {(--disable-werror)})
        (AndOr
          children: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [{(nice)} {(-n)} {(20)} {(make)} {(-j)} {($ VSub_Name "$CPUS")}]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[507])]
                )
                (C {(tee)} {(build/logs/alt-qemu.txt)})
              ]
              negated: False
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:QPATH)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (ForEach
                                  iter_name: i
                                  iter_words: [{(Lit_Other "*") (-softmmu)}]
                                  do_arg_iter: False
                                  body: 
                                    (DoGroup
                                      children: [
                                        (Sentence
                                          child: 
                                            (C {(echo)} {(-n)} 
                                              {
                                                (CommandSubPart
                                                  command_list: (CommandList children:[(C {(pwd)})])
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [536 538]
                                                ) (/) ($ VSub_Name "$i") (Lit_Other ":")
                                              }
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      spids: [530 544]
                                    )
                                  spids: [526 529]
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [520 545]
                        )
                      )
                    }
                  spids: [518]
                )
              ]
              spids: [518]
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (C {(popd)})
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$QPATH"))} {(Lit_Other "]")})
        (SimpleCommand
          words: [
            {(more/for-each-target.sh)}
            {
              (SQ 
                <
"more/smoketest.sh $TARGET | tee snapshots/$SNAPSHOT_DATE/base/logs/newqemu-smoketest-$TARGET.txt"
                >
              )
            }
          ]
          more_env: [
            (env_pair
              name: PATH
              val: {(DQ ($ VSub_Name "$QPATH") (":") ($ VSub_Name "$PATH"))}
              spids: [568]
            )
          ]
        )
      ]
      op_id: Op_DPipe
    )
  ]
)