#!/usr/bin/python
#

# Copyright (C) 2006, 2007 Google Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.


# pylint: disable-msg=W0401,W0614
# W0401: Wildcard import ganeti.cli
# W0614: Unused import %s from wildcard import (since we need cli)

import sys
import simplejson
import time

from optparse import make_option

from ganeti.cli import *
from ganeti import cli
from ganeti import opcodes
from ganeti import constants
from ganeti import utils
from ganeti import errors


def Delay(opts, args):
  """Sleeps for a while

  @param opts: the command line options selected by the user
  @type args: list
  @param args: should contain only one element, the duration
      the sleep
  @rtype: int
  @return: the desired exit code

  """
  delay = float(args[0])
  op = opcodes.OpTestDelay(duration=delay,
                           on_master=opts.on_master,
                           on_nodes=opts.on_nodes)
  SubmitOpCode(op)

  return 0


def GenericOpCodes(opts, args):
  """Send any opcode to the master.

  @todo: The function is broken and needs to be converted to the
      current job queue API
  @param opts: the command line options selected by the user
  @type args: list
  @param args: should contain only one element, the path of
      the file with the opcode definition
  @rtype: int
  @return: the desired exit code

  """
  cl = cli.GetClient()
  jex = cli.JobExecutor(cl=cl, verbose=opts.verbose)

  job_cnt = 0
  op_cnt = 0
  if opts.timing_stats:
    ToStdout("Loading...")
  for job_idx in range(opts.rep_job):
    for fname in args:
      op_data = simplejson.loads(open(fname).read())
      op_list = [opcodes.OpCode.LoadOpCode(val) for val in op_data]
      op_list = op_list * opts.rep_op
      jex.QueueJob("file %s/%d" % (fname, job_idx), *op_list)
      op_cnt += len(op_list)
      job_cnt += 1

  if opts.timing_stats:
    t1 = time.time()
    ToStdout("Submitting...")
  jex.SubmitPending()

  if opts.timing_stats:
    t2 = time.time()
    ToStdout("Executing...")
  jex.GetResults()
  if opts.timing_stats:
    t3 = time.time()
    ToStdout("C:op     %4d" % op_cnt)
    ToStdout("C:job    %4d" % job_cnt)
    ToStdout("T:submit %4.4f" % (t2-t1))
    ToStdout("T:exec   %4.4f" % (t3-t2))
    ToStdout("T:total  %4.4f" % (t3-t1))
  return 0


def TestAllocator(opts, args):
  """Runs the test allocator opcode.

  @param opts: the command line options selected by the user
  @type args: list
  @param args: should contain only one element, the iallocator name
  @rtype: int
  @return: the desired exit code

  """
  try:
    disks = [{"size": utils.ParseUnit(val), "mode": 'w'}
             for val in opts.disks.split(",")]
  except errors.UnitParseError, err:
    ToStderr("Invalid disks parameter '%s': %s", opts.disks, err)
    return 1

  nics = [val.split("/") for val in opts.nics.split(",")]
  for row in nics:
    while len(row) < 3:
      row.append(None)
    for i in range(3):
      if row[i] == '':
        row[i] = None
  nic_dict = [{"mac": v[0], "ip": v[1], "bridge": v[2]} for v in nics]

  if opts.tags is None:
    opts.tags = []
  else:
    opts.tags = opts.tags.split(",")

  op = opcodes.OpTestAllocator(mode=opts.mode,
                               name=args[0],
                               mem_size=opts.mem,
                               disks=disks,
                               disk_template=opts.disk_template,
                               nics=nic_dict,
                               os=opts.os_type,
                               vcpus=opts.vcpus,
                               tags=opts.tags,
                               direction=opts.direction,
                               allocator=opts.allocator,
                               )
  result = SubmitOpCode(op)
  ToStdout("%s" % result)
  return 0


commands = {
  'delay': (Delay, ARGS_ONE,
            [DEBUG_OPT,
             make_option("--no-master", dest="on_master", default=True,
                         action="store_false",
                         help="Do not sleep in the master code"),
             make_option("-n", dest="on_nodes", default=[],
                         action="append",
                         help="Select nodes to sleep on"),
             ],
            "[opts...] <duration>", "Executes a TestDelay OpCode"),
  'submit-job': (GenericOpCodes, ARGS_ATLEAST(1),
                 [DEBUG_OPT,
                  make_option("--op-repeat", type="int", default="1",
                              dest="rep_op",
                              help="Repeat the opcode sequence this number"
                              " of times"),
                  make_option("--job-repeat", type="int", default="1",
                              dest="rep_job",
                              help="Repeat the job this number"
                              " of times"),
                  make_option("-v", "--verbose", default=False,
                              action="store_true",
                              help="Make the operation more verbose"),
                  make_option("--timing-stats", default=False,
                              action="store_true",
                              help="Show timing stats"),
                  ],
                 "<op_list_file...>", "Submits jobs built from json files"
                 " containing a list of serialized opcodes"),
  'allocator': (TestAllocator, ARGS_ONE,
                [DEBUG_OPT,
                 make_option("--dir", dest="direction",
                             default="in", choices=["in", "out"],
                             help="Show allocator input (in) or allocator"
                             " results (out)"),
                 make_option("--algorithm", dest="allocator",
                             default=None,
                             help="Allocator algorithm name"),
                 make_option("-m", "--mode", default="relocate",
                             choices=["relocate", "allocate"],
                             help="Request mode, either allocate or"
                             " relocate"),
                 cli_option("--mem", default=128, type="unit",
                            help="Memory size for the instance (MiB)"),
                 make_option("--disks", default="4096,4096",
                             help="Comma separated list of disk sizes (MiB)"),
                 make_option("-t", "--disk-template", default="drbd",
                             help="Select the disk template"),
                 make_option("--nics", default="00:11:22:33:44:55",
                             help="Comma separated list of nics, each nic"
                             " definition is of form mac/ip/bridge, if"
                             " missing values are replace by None"),
                 make_option("-o", "--os-type", default=None,
                             help="Select os for the instance"),
                 make_option("-p", "--vcpus", default=1, type="int",
                             help="Select number of VCPUs for the instance"),
                 make_option("--tags", default=None,
                             help="Comma separated list of tags"),
                 ],
                "{opts...} <instance>", "Executes a TestAllocator OpCode"),
  }


if __name__ == '__main__':
  sys.exit(GenericMain(commands))
