Synnefo » snf-ganeti » ganeti-local

from ganeti import daemon

def CheckMASTERD(options, args):

  """Initial checks whether to run or exit with a failure

  """

def ExecMASTERD(options, args):

  """Main MASTERD function, executed with the pidfile held.

  """

  # This is safe to do as the pid file guarantees against

  # concurrent execution.

  utils.RemoveFile(constants.MASTER_SOCKET)

  master = IOServer(constants.MASTER_SOCKET, ClientRqHandler)

  try:

def main():

  """Main function"""

  parser = OptionParser(description="Ganeti master daemon",

                        usage="%prog [-f] [-d]",

                        version="%%prog (ganeti) %s" %

                        constants.RELEASE_VERSION)

  parser.add_option("--no-voting", dest="no_voting",

                    help="Do not check that the nodes agree on this node"

                    " being the master and start the daemon unconditionally",

                    default=False, action="store_true")

  parser.add_option("--yes-do-it", dest="yes_do_it",

                    help="Override interactive check for --no-voting",

                    default=False, action="store_true")

  dirs = [(constants.RUN_GANETI_DIR, constants.RUN_DIRS_MODE),

          (constants.SOCKET_DIR, constants.SOCKET_DIR_MODE),

         ]

  daemon.GenericMain(constants.MASTERD, parser, dirs,

                     CheckMASTERD, ExecMASTERD)

def CheckNODED(options, args):

  """Initial checks whether to run exit with a failure

  for fname in (constants.SSL_CERT_FILE,):

    if not os.path.isfile(fname):

      print "config %s not there, will not run." % fname

      sys.exit(constants.EXIT_NOTCLUSTER)

def ExecNODED(options, args):

  """Main NODED function, executed with the pidfile held.

  # Read SSL certificate

  ssl_params = http.HttpSslParams(ssl_key_path=constants.SSL_CERT_FILE,

                                  ssl_cert_path=constants.SSL_CERT_FILE)

  # Prepare job queue

  queue_lock = jstore.InitAndVerifyQueue(must_lock=False)

  mainloop = daemon.Mainloop()

  server = NodeHttpServer(mainloop, options.bind_address, options.port,

                          ssl_params=ssl_params, ssl_verify_peer=True)

  server.Start()

  try:

    mainloop.Run()

  finally:

    server.Stop()

def main():

  """Main function for the node daemon.

  """

  parser = OptionParser(description="Ganeti node daemon",

                        usage="%prog [-f] [-d] [-p port] [-b ADDRESS]",

                        version="%%prog (ganeti) %s" %

                        constants.RELEASE_VERSION)

  daemon.GenericMain(constants.NODED, parser, dirs, CheckNODED, ExecNODED)

def CheckRAPI(options, args):

  """Initial checks whether to run or exit with a failure

    print >> sys.stderr, "Usage: %s [-f] [-d] [-p port] [-b ADDRESS]" % \

        sys.argv[0]

  if options.ssl:

    if not (options.ssl_cert and options.ssl_key):

      print >> sys.stderr, ("For secure mode please provide "

                            "--ssl-key and --ssl-cert arguments")

      sys.exit(constants.EXIT_FAILURE)

    for fname in (options.ssl_cert, options.ssl_key):

      if not os.path.isfile(fname):

        print >> sys.stderr, "config %s not there, will not run." % fname

        sys.exit(constants.EXIT_FAILURE)

  ssconf.CheckMaster(options.debug)

def ExecRAPI(options, args):

  """Main RAPI function, executed with the pidfile held.

  # Read SSL certificate

    ssl_params = http.HttpSslParams(ssl_key_path=options.ssl_key,

                                    ssl_cert_path=options.ssl_cert)

  mainloop = daemon.Mainloop()

  server = RemoteApiHttpServer(mainloop, options.bind_address, options.port,

                               ssl_params=ssl_params, ssl_verify_peer=False,

                               request_executor_class=JsonErrorRequestExecutor)

  server.Start()

  try:

    mainloop.Run()

  finally:

    server.Stop()

def main():

  """Main function.

  """

  parser = optparse.OptionParser(description="Ganeti Remote API",

                    usage="%prog [-f] [-d] [-p port] [-b ADDRESS]",

                    version="%%prog (ganeti) %s" % constants.RAPI_VERSION)

  parser.add_option("--no-ssl", dest="ssl",

                    help="Do not secure HTTP protocol with SSL",

                    default=True, action="store_false")

  parser.add_option("-K", "--ssl-key", dest="ssl_key",

                    help="SSL key",

                    default=constants.RAPI_CERT_FILE, type="string")

  parser.add_option("-C", "--ssl-cert", dest="ssl_cert",

                    help="SSL certificate",

                    default=constants.RAPI_CERT_FILE, type="string")

  dirs = [(val, constants.RUN_DIRS_MODE) for val in constants.SUB_RUN_DIRS]

  dirs.append((constants.LOG_OS_DIR, 0750))

  daemon.GenericMain(constants.RAPI, parser, dirs, CheckRAPI, ExecRAPI)

MULTITHREADED_DAEMONS = frozenset([MASTERD])

import logging

from ganeti import constants

def GenericMain(daemon_name, optionparser, dirs, check_fn, exec_fn):

  """Shared main function for daemons.

  @type daemon_name: string

  @param daemon_name: daemon name

  @type optionparser: L{optparse.OptionParser}

  @param optionparser: initialized optionparser with daemon-specific options

                       (common -f -d options will be handled by this module)

  @type options: object @param options: OptionParser result, should contain at

                 least the fork and the debug options

  @type dirs: list of strings

  @param dirs: list of directories that must exist for this daemon to work

  @type check_fn: function which accepts (options, args)

  @param check_fn: function that checks start conditions and exits if they're

                   not met

  @type exec_fn: function which accepts (options, args)

  @param exec_fn: function that's executed with the daemon's pid file held, and

                  runs the daemon itself.

  """

  optionparser.add_option("-f", "--foreground", dest="fork",

                          help="Don't detach from the current terminal",

                          default=True, action="store_false")

  optionparser.add_option("-d", "--debug", dest="debug",

                          help="Enable some debug messages",

                          default=False, action="store_true")

  if daemon_name in constants.DAEMONS_PORTS:

    # for networked daemons we also allow choosing the bind port and address.

    # by default we use the port provided by utils.GetDaemonPort, and bind to

    # 0.0.0.0 (which is represented by and empty bind address.

    port = utils.GetDaemonPort(daemon_name)

    optionparser.add_option("-p", "--port", dest="port",

                            help="Network port (%s default)." % port,

                            default=port, type="int")

    optionparser.add_option("-b", "--bind", dest="bind_address",

                            help="Bind address",

                            default="", metavar="ADDRESS")

  multithread = utils.no_fork = daemon_name in constants.MULTITHREADED_DAEMONS

  options, args = optionparser.parse_args()

  check_fn(options, args)

  utils.EnsureDirs(dirs)

  if options.fork:

    utils.CloseFDs()

    utils.Daemonize(logfile=constants.DAEMONS_LOGFILES[daemon_name])

  utils.WritePidFile(daemon_name)

  try:

    utils.SetupLogging(logfile=constants.DAEMONS_LOGFILES[daemon_name],

                       debug=options.debug,

                       stderr_logging=not options.fork,

                       multithreaded=multithread)

    logging.info("%s daemon startup" % daemon_name)

    exec_fn(options, args)

  finally:

    utils.RemovePidFile(daemon_name)