Göran Krampe / Blimp

  import md5, os, osproc, parseopt2, strutils, parsecfg, streams, lapp, subexes

  # blimp is a little utility program for handling large files

  # in git repositories. Its inspired by git-fat and s3annex

  # but doesn't rely on S3 for storage, is a single binary without
  # need for Python, and has less features than git-fat. So far.

  #

  # Manual use:
  #
  # Use "blimp d mybigfile" to deflate it before commit.
  # Use "blimp i mybigfile" to inflate it back to original size.

  #
  # When deflated the file only has an md5sum string inside it.
  #
  # The file is copied over into:

  #  <homedir>/blimpStore/<originalfilename>-<md5sum>
  #
  # Configuration is in:
  #   <gitroot>/.blimp.conf
  #   ~/blimpstore/.blimp.conf

  var
    blimpStore, uploadCommandFormat, downloadCommandFormat: string
    remoteBlimpStore: string = nil
    verbose: bool

  let
    defaultConfig = """
  [rsync]
  remote = "blimp@some-rsync-server.com::blimpstore"
  # $1 is filename, $2 is remote and $3 is the local blimpstore
  upload = "rsync --password-file ~/blimp.pass -avzP $3/$1 $2/"
  download = "rsync -avzP $2/$1 $3/"
  """

  # Load blimp.conf file, overkill for now but...

  proc parseConfFile(filename: string) =

    var f = newFileStream(filename, fmRead)
    if f != nil:
      var p: CfgParser
      open(p, f, filename)
      while true:
        var e = next(p)
        case e.kind
        of cfgEof: 
          break
        of cfgSectionStart:
          continue # Ignore
        of cfgKeyValuePair:

          case e.key
          of "remote":

            remoteBlimpStore = e.value

          of "upload":
            uploadCommandFormat = e.value
          of "download":
            downloadCommandFormat = e.value

          else:
            quit("Unknown configuration: " & e.key)
        of cfgOption:
          quit("Unknown configuration: " & e.key)
        of cfgError:
          quit("Parsing " & filename & ": " & e.msg)
      close(p)
  

  # Trivial helper to enable verbose
  proc run(cmd: string): auto =
    if verbose: echo(cmd)
    execCmd(cmd)

  # Upload a file to the remote master blimpStore
  proc uploadFile(blimpFilename: string) =
    if remoteBlimpStore.isNil:
      echo("Remote blimpstore not set in configuration file, not uploading content:\n\t" & blimpFilename)

      return

    let errorCode = run(format(uploadCommandFormat, blimpFilename, remoteBlimpStore, blimpStore))
    if errorCode != 0:
      quit("Something went wrong uploading " & blimpFilename & " to " & remoteBlimpStore, 2)

  # Download a file to the remote master blimpStore
  proc downloadFile(blimpFilename: string) =
    if remoteBlimpStore.isNil:
      quit("Remote blimpstore not set in configuration file, can not download content:\n\t" & blimpFilename)

    let errorCode = run(format(downloadCommandFormat, blimpFilename, remoteBlimpStore, blimpStore))
    if errorCode != 0:
      quit("Something went wrong downloading " & blimpFilename & " from " & remoteBlimpStore, 3)

  
  
  # Copy content to blimpStore, no upload yet.
  proc copyToBlimpStore(filename, blimpFilename: string) =
    if not existsFile(blimpStore / blimpFilename):
      copyFile(filename, blimpStore / blimpFilename)
      uploadFile(blimpFilename)
  
  # Copy content from blimpStore, and downloading first if needed
  proc copyFromblimpStore(blimpFilename, filename: string) =
    if not existsFile(blimpStore / blimpFilename):
      downloadFile(blimpFilename)
    copyFile(blimpStore / blimpFilename, filename)

  # Copy original file to blimpStore and replace with hash stub in git.

  proc deflate(filename: string) =

    var content: string
    try:
      content = readFile(filename)
    except:
      quit("Failed opening file: " & filename, 1)

    if content[0..4] == "hash:":
      quit("File is already deflated, ignored.", 5)
    let hash = getMD5(content)

    let blimpFilename = filename & "-" & hash
    copyToBlimpStore(filename, blimpFilename)
    writeFile(filename, "hash:" & blimpFilename)

    echo("\t" & filename & " deflated.")
    

  # Parse out hash from hash stub and copy back original content from blimpStore.

  proc inflate(filename: string) =
    var hashfile: File
    if not open(hashfile, filename):

      quit("Failed opening file: " & filename, 4)

    let hashline = split(string(readLine(hashfile)), {':'})
    if hashline[0] == "hash":

      let blimpfilename = hashline[1]

      #removeFile(filename)

      copyFromblimpStore(blimpfilename, filename)

    else:

      quit("\t" & filename & " is not deflated.", 5)
    echo("\t" & filename & " inflated.")

  
  # Find git root dir or fall back on current dir
  proc gitRoot(): string =
    try:
      let tup = execCmdEx("git rev-parse --show-toplevel")
      if tup[1] == 0:
        result = tup[0]
      else:
        result = getCurrentDir()
    except:
      result = getCurrentDir()

  let help = """
    blimp [options] <command> <filenames...>
      -v,--verbose             Verbosity
      <command>   (string)     (i)nflate or (d)eflate
      <filenames> (string...)  One or more filepaths to inflate/deflate
    """
  

  ################################ main #####################################
  

  # Hardwired to "blimpstore" directory in home dir.
  blimpStore = getHomeDir() / "blimpstore"

  
  # Make sure we have the dir, or create it.
  try:

    if not existsDir(blimpStore):
      createDir(blimpStore)
    if not existsFile(blimpStore / ".blimp.conf"):
      writeFile(blimpStore / ".blimp.conf", defaultConfig)

  except:

    quit("Could not create " & blimpStore & " directory.", 1)

  # Parse configuration files if they exist
  parseConfFile(gitRoot() / ".blimp.conf")
  parseConfFile(blimpStore / ".blimp.conf")

  # Using lapp to get args
  let args = parse(help)
  let command = args["command"].asString
  let filenames = args["filenames"].asSeq
  verbose = args["verbose"].asBool

  
  # Do the deed
  if command == "d" or command == "deflate":

    for fn in filenames:
      deflate(fn.asString)

  elif command == "i" or command == "inflate":

    for fn in filenames:
      inflate(fn.asString)

  else:
    quit("Unknown command, only (d)eflate or (i)inflate are valid.", 6)
  
  # All good
  quit(0)