#!/usr/bin/python2.5
#
# Copyright 2008 the Melange authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Script to export a Google App Engine "image" of a Melange application.

For details:
  trunk/scripts/export_image.py --help

Default values for flags can be specified in valid Python syntax in the
~/.soc_scripts_settings file.  See settings.py for details.
"""

__authors__ = [
  # alphabetical order by last name, please
  '"Todd Larsen" <tlarsen@google.com>',
]


import os
import sys

import pysvn

from trunk.scripts import app_image
from trunk.scripts import settings
from trunk.scripts import svn_helper


def buildOptionList(defaults={}):
  """Returns a list of command-line settings.Options for this script.

  Args:
    defaults: dict of possible pre-loaded default values; default is empty
      dict (which is safe because it is not altered)
  """
  def_repo = defaults.get('repo')

  if def_repo:
    repo_help_msg = 'SVN repository; default is %s' % def_repo
  else:
    repo_help_msg = 'SVN repository; REQUIRED if a default is missing'

  return [
      settings.Option(
          '-R', '--repo', action='store', dest='repo',
          default=def_repo, help=repo_help_msg),
      settings.Option(
          '-s', '--src', action='store', dest='src', required=True,
          help='(REQUIRED) name of source app in /trunk/apps/ to export'),
      settings.Option(
          '-i', '--image', action='store', dest='image', required=True,
          help='(REQUIRED) exported image destination'),
      settings.Option(
          '-r', '--rev', type='int', action='store', dest='rev',
          default=None, help='optional revision number on which to export'),
  ]


def main(args):
  # create parser just for usage info before settings file is read successfully
  usage_parser = settings.OptionParser(option_list=buildOptionList())

  # attempt to read the common trunk/scripts settings file
  defaults = settings.readPythonSettingsOrDie(parser=usage_parser)

  # create the command-line options parser
  parser = settings.makeOptionParserOrDie(
      option_list=buildOptionList(defaults))

  # parse the command-line options
  options, args = settings.parseOptionsOrDie(parser, args)

  # ensure that various paths end with the / separator
  src, image, repo = svn_helper.formatDirPaths(
      options.src, options.image, options.repo)

  # expand and make "OS-agnostic" the proposed App Engine image path
  # (which is why no working copy path is needed or supplied)
  image = svn_helper.getExpandedWorkingCopyPath(image)

  setup_errors = []

  if os.path.exists(image):
    setup_errors.extend(
        ['--image destination directory must not already exist:',
         '  %s' % image])

  # dirname() called twice because image always ends with os.sep as a result
  # of svn_helper.getExpandedWorkingCopyPath()
  parent_dir = os.path.dirname(os.path.dirname(image))

  if not os.path.isdir(parent_dir):
    try:
      os.makedirs(parent_dir)
      print 'Created --image parent directory:\n %s\n' % parent_dir
    except (IOError, OSError), fs_err:
      setup_errors.extend(
          ['--image parent directory could not be created:',
           '  %s' % parent_dir,
           '  %s: %s' % (fs_err.__class__.__name__,
                       ' '.join([str(arg) for arg in fs_err.args]))])

  if not options.repo:
    setup_errors.extend(
        ['--repo must be supplied or have a settings file default'])

  if setup_errors:
    return settings.printErrorsAndUsage(setup_errors, parser)

  def callbackGetLogMessage():
    return True, 'trunk/apps/%s application exported to %s' % (src, image)

  client = svn_helper.getPySvnClient()
  # this should never actually be called, but just in case...
  client.callback_get_log_message = callbackGetLogMessage

  # export trunk/apps/<src> first, so image root directory will exist
  app_image.exportFromSrcApp(src, repo, image, rev=options.rev)
  app_image.exportFromThirdParty(repo, image, rev=options.rev)
  app_image.exportFromFramework(repo, image, rev=options.rev)

  return 0


if __name__ == '__main__':
  sys.exit(main(sys.argv))