X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/3c9a0742ac151c0557416701bb1b1c8e0534f35b..2cc1da8b07305c1c322a5524a7e24ea07b071d72:/daemons/ganeti-noded diff --git a/daemons/ganeti-noded b/daemons/ganeti-noded index 9c09140..c29db72 100755 --- a/daemons/ganeti-noded +++ b/daemons/ganeti-noded @@ -21,286 +21,717 @@ """Ganeti node daemon""" +# functions in this module need to have a given name structure, so: +# pylint: disable-msg=C0103 + import os import sys -import resource import traceback +import SocketServer +import errno +import logging +import signal from optparse import OptionParser - from ganeti import backend -from ganeti import logger from ganeti import constants from ganeti import objects from ganeti import errors -from ganeti import ssconf +from ganeti import jstore +from ganeti import daemon +from ganeti import http +from ganeti import utils + +import ganeti.http.server + -from twisted.spread import pb -from twisted.internet import reactor -from twisted.cred import checkers, portal -from OpenSSL import SSL +queue_lock = None -class ServerContextFactory: - def getContext(self): - ctx = SSL.Context(SSL.TLSv1_METHOD) - ctx.use_certificate_file(constants.SSL_CERT_FILE) - ctx.use_privatekey_file(constants.SSL_CERT_FILE) - return ctx +def _RequireJobQueueLock(fn): + """Decorator for job queue manipulating functions. -class ServerObject(pb.Avatar): - def __init__(self, name): - self.name = name + """ + QUEUE_LOCK_TIMEOUT = 10 + + def wrapper(*args, **kwargs): + # Locking in exclusive, blocking mode because there could be several + # children running at the same time. Waiting up to 10 seconds. + queue_lock.Exclusive(blocking=True, timeout=QUEUE_LOCK_TIMEOUT) + try: + return fn(*args, **kwargs) + finally: + queue_lock.Unlock() - def perspectiveMessageReceived(self, broker, message, args, kw): - """This method is called when a network message is received. + return wrapper - I will call:: - | self.perspective_%(message)s(*broker.unserialize(args), - | **broker.unserialize(kw)) +class NodeHttpServer(http.server.HttpServer): + """The server implementation. + + This class holds all methods exposed over the RPC interface. + + """ + def __init__(self, *args, **kwargs): + http.server.HttpServer.__init__(self, *args, **kwargs) + self.noded_pid = os.getpid() + + def HandleRequest(self, req): + """Handle a request. - to handle the method; subclasses of Avatar are expected to - implement methods of this naming convention. """ + if req.request_method.upper() != http.HTTP_PUT: + raise http.HttpBadRequest() - args = broker.unserialize(args, self) - kw = broker.unserialize(kw, self) - method = getattr(self, "perspective_%s" % message) - tb = None - state = None - try: - state = method(*args, **kw) - except: - tb = traceback.format_exc() + path = req.request_path + if path.startswith("/"): + path = path[1:] - return broker.serialize((tb, state), self, method, args, kw) + method = getattr(self, "perspective_%s" % path, None) + if method is None: + raise http.HttpNotFound() + + try: + try: + return method(req.request_body) + except: + logging.exception("Error in RPC call") + raise + except errors.QuitGanetiException, err: + # Tell parent to quit + os.kill(self.noded_pid, signal.SIGTERM) # the new block devices -------------------------- - def perspective_blockdev_create(self,params): - bdev_s, size, on_primary = params - bdev = objects.ConfigObject.Loads(bdev_s) + @staticmethod + def perspective_blockdev_create(params): + """Create a block device. + + """ + bdev_s, size, owner, on_primary, info = params + bdev = objects.Disk.FromDict(bdev_s) if bdev is None: raise ValueError("can't unserialize data!") - return backend.CreateBlockDevice(bdev, size, on_primary) + return backend.BlockdevCreate(bdev, size, owner, on_primary, info) + @staticmethod + def perspective_blockdev_remove(params): + """Remove a block device. - def perspective_blockdev_remove(self,params): + """ bdev_s = params[0] - bdev = objects.ConfigObject.Loads(bdev_s) - return backend.RemoveBlockDevice(bdev) + bdev = objects.Disk.FromDict(bdev_s) + return backend.BlockdevRemove(bdev) + + @staticmethod + def perspective_blockdev_rename(params): + """Remove a block device. + + """ + devlist = [(objects.Disk.FromDict(ds), uid) for ds, uid in params] + return backend.BlockdevRename(devlist) + @staticmethod + def perspective_blockdev_assemble(params): + """Assemble a block device. - def perspective_blockdev_assemble(self,params): - bdev_s, on_primary = params - bdev = objects.ConfigObject.Loads(bdev_s) + """ + bdev_s, owner, on_primary = params + bdev = objects.Disk.FromDict(bdev_s) if bdev is None: raise ValueError("can't unserialize data!") - return backend.AssembleBlockDevice(bdev, on_primary) + return backend.BlockdevAssemble(bdev, owner, on_primary) + @staticmethod + def perspective_blockdev_shutdown(params): + """Shutdown a block device. - def perspective_blockdev_shutdown(self,params): + """ bdev_s = params[0] - bdev = objects.ConfigObject.Loads(bdev_s) + bdev = objects.Disk.FromDict(bdev_s) if bdev is None: raise ValueError("can't unserialize data!") - return backend.ShutdownBlockDevice(bdev) + return backend.BlockdevShutdown(bdev) + @staticmethod + def perspective_blockdev_addchildren(params): + """Add a child to a mirror device. - def perspective_blockdev_addchild(self,params): + Note: this is only valid for mirror devices. It's the caller's duty + to send a correct disk, otherwise we raise an error. + + """ bdev_s, ndev_s = params - bdev = objects.ConfigObject.Loads(bdev_s) - ndev = objects.ConfigObject.Loads(ndev_s) - if bdev is None or ndev is None: + bdev = objects.Disk.FromDict(bdev_s) + ndevs = [objects.Disk.FromDict(disk_s) for disk_s in ndev_s] + if bdev is None or ndevs.count(None) > 0: raise ValueError("can't unserialize data!") - return backend.MirrorAddChild(bdev, ndev) + return backend.BlockdevAddchildren(bdev, ndevs) + + @staticmethod + def perspective_blockdev_removechildren(params): + """Remove a child from a mirror device. + This is only valid for mirror devices, of course. It's the callers + duty to send a correct disk, otherwise we raise an error. - def perspective_blockdev_removechild(self,params): + """ bdev_s, ndev_s = params - bdev = objects.ConfigObject.Loads(bdev_s) - ndev = objects.ConfigObject.Loads(ndev_s) - if bdev is None or ndev is None: + bdev = objects.Disk.FromDict(bdev_s) + ndevs = [objects.Disk.FromDict(disk_s) for disk_s in ndev_s] + if bdev is None or ndevs.count(None) > 0: raise ValueError("can't unserialize data!") - return backend.MirrorRemoveChild(bdev, ndev) + return backend.BlockdevRemovechildren(bdev, ndevs) + + @staticmethod + def perspective_blockdev_getmirrorstatus(params): + """Return the mirror status for a list of disks. - def perspective_blockdev_getmirrorstatus(self, params): - disks = [objects.ConfigObject.Loads(dsk_s) + """ + disks = [objects.Disk.FromDict(dsk_s) for dsk_s in params] - return backend.GetMirrorStatus(disks) + return backend.BlockdevGetmirrorstatus(disks) + + @staticmethod + def perspective_blockdev_find(params): + """Expose the FindBlockDevice functionality for a disk. + + This will try to find but not activate a disk. + + """ + disk = objects.Disk.FromDict(params[0]) + return backend.BlockdevFind(disk) + + @staticmethod + def perspective_blockdev_snapshot(params): + """Create a snapshot device. + + Note that this is only valid for LVM disks, if we get passed + something else we raise an exception. The snapshot device can be + remove by calling the generic block device remove call. + + """ + cfbd = objects.Disk.FromDict(params[0]) + return backend.BlockdevSnapshot(cfbd) + + @staticmethod + def perspective_blockdev_grow(params): + """Grow a stack of devices. + + """ + cfbd = objects.Disk.FromDict(params[0]) + amount = params[1] + return backend.BlockdevGrow(cfbd, amount) + + @staticmethod + def perspective_blockdev_close(params): + """Closes the given block devices. + + """ + disks = [objects.Disk.FromDict(cf) for cf in params[1]] + return backend.BlockdevClose(params[0], disks) + + # blockdev/drbd specific methods ---------- + + @staticmethod + def perspective_drbd_disconnect_net(params): + """Disconnects the network connection of drbd disks. + + Note that this is only valid for drbd disks, so the members of the + disk list must all be drbd devices. + + """ + nodes_ip, disks = params + disks = [objects.Disk.FromDict(cf) for cf in disks] + return backend.DrbdDisconnectNet(nodes_ip, disks) + + @staticmethod + def perspective_drbd_attach_net(params): + """Attaches the network connection of drbd disks. + + Note that this is only valid for drbd disks, so the members of the + disk list must all be drbd devices. + + """ + nodes_ip, disks, instance_name, multimaster = params + disks = [objects.Disk.FromDict(cf) for cf in disks] + return backend.DrbdAttachNet(nodes_ip, disks, + instance_name, multimaster) + + @staticmethod + def perspective_drbd_wait_sync(params): + """Wait until DRBD disks are synched. - def perspective_blockdev_find(self, params): - disk = objects.ConfigObject.Loads(params[0]) - return backend.FindBlockDevice(disk) + Note that this is only valid for drbd disks, so the members of the + disk list must all be drbd devices. - def perspective_blockdev_snapshot(self,params): - cfbd = objects.ConfigObject.Loads(params[0]) - return backend.SnapshotBlockDevice(cfbd) + """ + nodes_ip, disks = params + disks = [objects.Disk.FromDict(cf) for cf in disks] + return backend.DrbdWaitSync(nodes_ip, disks) # export/import -------------------------- - def perspective_snapshot_export(self,params): - disk = objects.ConfigObject.Loads(params[0]) + @staticmethod + def perspective_snapshot_export(params): + """Export a given snapshot. + + """ + disk = objects.Disk.FromDict(params[0]) dest_node = params[1] - instance = objects.ConfigObject.Loads(params[2]) - return backend.ExportSnapshot(disk,dest_node,instance) + instance = objects.Instance.FromDict(params[2]) + cluster_name = params[3] + dev_idx = params[4] + return backend.ExportSnapshot(disk, dest_node, instance, + cluster_name, dev_idx) + + @staticmethod + def perspective_finalize_export(params): + """Expose the finalize export functionality. - def perspective_finalize_export(self,params): - instance = objects.ConfigObject.Loads(params[0]) - snap_disks = [objects.ConfigObject.Loads(str_data) + """ + instance = objects.Instance.FromDict(params[0]) + snap_disks = [objects.Disk.FromDict(str_data) for str_data in params[1]] return backend.FinalizeExport(instance, snap_disks) - def perspective_export_info(self,params): - dir = params[0] - einfo = backend.ExportInfo(dir) + @staticmethod + def perspective_export_info(params): + """Query information about an existing export on this node. + + The given path may not contain an export, in which case we return + None. + + """ + path = params[0] + einfo = backend.ExportInfo(path) if einfo is None: return einfo return einfo.Dumps() - def perspective_export_list(self, params): + @staticmethod + def perspective_export_list(params): + """List the available exports on this node. + + Note that as opposed to export_info, which may query data about an + export in any path, this only queries the standard Ganeti path + (constants.EXPORT_DIR). + + """ return backend.ListExports() - def perspective_export_remove(self, params): + @staticmethod + def perspective_export_remove(params): + """Remove an export. + + """ export = params[0] return backend.RemoveExport(export) # volume -------------------------- - def perspective_volume_list(self,params): + @staticmethod + def perspective_volume_list(params): + """Query the list of logical volumes in a given volume group. + + """ vgname = params[0] return backend.GetVolumeList(vgname) - def perspective_vg_list(self,params): + @staticmethod + def perspective_vg_list(params): + """Query the list of volume groups. + + """ return backend.ListVolumeGroups() # bridge -------------------------- - def perspective_bridges_exist(self,params): + @staticmethod + def perspective_bridges_exist(params): + """Check if all bridges given exist on this node. + + """ bridges_list = params[0] return backend.BridgesExist(bridges_list) # instance -------------------------- - def perspective_instance_os_add(self,params): - inst_s, os_disk, swap_disk = params - inst = objects.ConfigObject.Loads(inst_s) - return backend.AddOSToInstance(inst, os_disk, swap_disk) + @staticmethod + def perspective_instance_os_add(params): + """Install an OS on a given instance. + + """ + inst_s = params[0] + inst = objects.Instance.FromDict(inst_s) + reinstall = params[1] + return backend.InstanceOsAdd(inst, reinstall) + + @staticmethod + def perspective_instance_run_rename(params): + """Runs the OS rename script for an instance. + + """ + inst_s, old_name = params + inst = objects.Instance.FromDict(inst_s) + return backend.RunRenameInstance(inst, old_name) - def perspective_instance_os_import(self, params): - inst_s, os_disk, swap_disk, src_node, src_image = params - inst = objects.ConfigObject.Loads(inst_s) - return backend.ImportOSIntoInstance(inst, os_disk, swap_disk, - src_node, src_image) + @staticmethod + def perspective_instance_os_import(params): + """Run the import function of an OS onto a given instance. - def perspective_instance_shutdown(self,params): - instance = objects.ConfigObject.Loads(params[0]) - return backend.ShutdownInstance(instance) + """ + inst_s, src_node, src_images, cluster_name = params + inst = objects.Instance.FromDict(inst_s) + return backend.ImportOSIntoInstance(inst, src_node, src_images, + cluster_name) - def perspective_instance_start(self,params): - instance = objects.ConfigObject.Loads(params[0]) - extra_args = params[1] - return backend.StartInstance(instance, extra_args) + @staticmethod + def perspective_instance_shutdown(params): + """Shutdown an instance. - def perspective_instance_info(self,params): - return backend.GetInstanceInfo(params[0]) + """ + instance = objects.Instance.FromDict(params[0]) + return backend.InstanceShutdown(instance) - def perspective_all_instances_info(self,params): - return backend.GetAllInstancesInfo() + @staticmethod + def perspective_instance_start(params): + """Start an instance. - def perspective_instance_list(self,params): - return backend.GetInstanceList() + """ + instance = objects.Instance.FromDict(params[0]) + return backend.StartInstance(instance) + + @staticmethod + def perspective_migration_info(params): + """Gather information about an instance to be migrated. + + """ + instance = objects.Instance.FromDict(params[0]) + return backend.MigrationInfo(instance) + + @staticmethod + def perspective_accept_instance(params): + """Prepare the node to accept an instance. + + """ + instance, info, target = params + instance = objects.Instance.FromDict(instance) + return backend.AcceptInstance(instance, info, target) + + @staticmethod + def perspective_finalize_migration(params): + """Finalize the instance migration. + + """ + instance, info, success = params + instance = objects.Instance.FromDict(instance) + return backend.FinalizeMigration(instance, info, success) + + @staticmethod + def perspective_instance_migrate(params): + """Migrates an instance. + + """ + instance, target, live = params + instance = objects.Instance.FromDict(instance) + return backend.MigrateInstance(instance, target, live) + + @staticmethod + def perspective_instance_reboot(params): + """Reboot an instance. + + """ + instance = objects.Instance.FromDict(params[0]) + reboot_type = params[1] + return backend.InstanceReboot(instance, reboot_type) + + @staticmethod + def perspective_instance_info(params): + """Query instance information. + + """ + return backend.GetInstanceInfo(params[0], params[1]) + + @staticmethod + def perspective_instance_migratable(params): + """Query whether the specified instance can be migrated. + + """ + instance = objects.Instance.FromDict(params[0]) + return backend.GetInstanceMigratable(instance) + + @staticmethod + def perspective_all_instances_info(params): + """Query information about all instances. + + """ + return backend.GetAllInstancesInfo(params[0]) + + @staticmethod + def perspective_instance_list(params): + """Query the list of running instances. + + """ + return backend.GetInstanceList(params[0]) # node -------------------------- - def perspective_node_info(self,params): - vgname = params[0] - return backend.GetNodeInfo(vgname) + @staticmethod + def perspective_node_tcp_ping(params): + """Do a TcpPing on the remote node. + + """ + return utils.TcpPing(params[1], params[2], timeout=params[3], + live_port_needed=params[4], source=params[0]) + + @staticmethod + def perspective_node_has_ip_address(params): + """Checks if a node has the given ip address. + + """ + return utils.OwnIpAddress(params[0]) + + @staticmethod + def perspective_node_info(params): + """Query node information. - def perspective_node_add(self,params): + """ + vgname, hypervisor_type = params + return backend.GetNodeInfo(vgname, hypervisor_type) + + @staticmethod + def perspective_node_add(params): + """Complete the registration of this node in the cluster. + + """ return backend.AddNode(params[0], params[1], params[2], params[3], params[4], params[5]) - def perspective_node_verify(self,params): - return backend.VerifyNode(params[0]) + @staticmethod + def perspective_node_verify(params): + """Run a verify sequence on this node. + + """ + return backend.VerifyNode(params[0], params[1]) + + @staticmethod + def perspective_node_start_master(params): + """Promote this node to master status. + + """ + return backend.StartMaster(params[0]) + + @staticmethod + def perspective_node_stop_master(params): + """Demote this node from master status. - def perspective_node_start_master(self, params): - return backend.StartMaster() + """ + return backend.StopMaster(params[0]) - def perspective_node_stop_master(self, params): - return backend.StopMaster() + @staticmethod + def perspective_node_leave_cluster(params): + """Cleanup after leaving a cluster. - def perspective_node_leave_cluster(self, params): + """ return backend.LeaveCluster() + @staticmethod + def perspective_node_volumes(params): + """Query the list of all logical volume groups. + + """ + return backend.NodeVolumes() + + @staticmethod + def perspective_node_demote_from_mc(params): + """Demote a node from the master candidate role. + + """ + return backend.DemoteFromMC() + + + @staticmethod + def perspective_node_powercycle(params): + """Tries to powercycle the nod. + + """ + hypervisor_type = params[0] + return backend.PowercycleNode(hypervisor_type) + + # cluster -------------------------- - def perspective_version(self,params): + @staticmethod + def perspective_version(params): + """Query version information. + + """ return constants.PROTOCOL_VERSION - def perspective_configfile_list(self,params): - return backend.ListConfigFiles() + @staticmethod + def perspective_upload_file(params): + """Upload a file. - def perspective_upload_file(self,params): + Note that the backend implementation imposes strict rules on which + files are accepted. + + """ return backend.UploadFile(*params) + @staticmethod + def perspective_master_info(params): + """Query master information. + + """ + return backend.GetMasterInfo() + + @staticmethod + def perspective_write_ssconf_files(params): + """Write ssconf files. + + """ + (values,) = params + return backend.WriteSsconfFiles(values) # os ----------------------- - def perspective_os_diagnose(self, params): - os_list = backend.DiagnoseOS() - if not os_list: - # this catches also return values of 'False', - # for which we can't iterate over - return os_list - result = [] - for data in os_list: - if isinstance(data, objects.OS): - result.append(data.Dumps()) - elif isinstance(data, errors.InvalidOS): - result.append(data.args) - else: - raise errors.ProgrammerError, ("Invalid result from backend.DiagnoseOS" - " (class %s, %s)" % - (str(data.__class__), data)) - - return result - - def perspective_os_get(self, params): + @staticmethod + def perspective_os_diagnose(params): + """Query detailed information about existing OSes. + + """ + return [os_obj.ToDict() for os_obj in backend.DiagnoseOS()] + + @staticmethod + def perspective_os_get(params): + """Query information about a given OS. + + """ name = params[0] try: - os = backend.OSFromDisk(name).Dumps() + os_obj = backend.OSFromDisk(name) except errors.InvalidOS, err: - os = err.args - return os + os_obj = objects.OS.FromInvalidOS(err) + return os_obj.ToDict() # hooks ----------------------- - def perspective_hooks_runner(self, params): + @staticmethod + def perspective_hooks_runner(params): + """Run hook scripts. + + """ hpath, phase, env = params hr = backend.HooksRunner() return hr.RunHooks(hpath, phase, env) + # iallocator ----------------- + + @staticmethod + def perspective_iallocator_runner(params): + """Run an iallocator script. + + """ + name, idata = params + iar = backend.IAllocatorRunner() + return iar.Run(name, idata) + + # test ----------------------- + + @staticmethod + def perspective_test_delay(params): + """Run test delay. + + """ + duration = params[0] + return utils.TestDelay(duration) + + # file storage --------------- + + @staticmethod + def perspective_file_storage_dir_create(params): + """Create the file storage directory. + + """ + file_storage_dir = params[0] + return backend.CreateFileStorageDir(file_storage_dir) -class MyRealm: - __implements__ = portal.IRealm - def requestAvatar(self, avatarId, mind, *interfaces): - if pb.IPerspective not in interfaces: - raise NotImplementedError - return pb.IPerspective, ServerObject(avatarId), lambda:None + @staticmethod + def perspective_file_storage_dir_remove(params): + """Remove the file storage directory. + + """ + file_storage_dir = params[0] + return backend.RemoveFileStorageDir(file_storage_dir) + + @staticmethod + def perspective_file_storage_dir_rename(params): + """Rename the file storage directory. + + """ + old_file_storage_dir = params[0] + new_file_storage_dir = params[1] + return backend.RenameFileStorageDir(old_file_storage_dir, + new_file_storage_dir) + + # jobs ------------------------ + + @staticmethod + @_RequireJobQueueLock + def perspective_jobqueue_update(params): + """Update job queue. + + """ + (file_name, content) = params + return backend.JobQueueUpdate(file_name, content) + + @staticmethod + @_RequireJobQueueLock + def perspective_jobqueue_purge(params): + """Purge job queue. + + """ + return backend.JobQueuePurge() + + @staticmethod + @_RequireJobQueueLock + def perspective_jobqueue_rename(params): + """Rename a job queue file. + + """ + # TODO: What if a file fails to rename? + return [backend.JobQueueRename(old, new) for old, new in params] + + @staticmethod + def perspective_jobqueue_set_drain(params): + """Set/unset the queue drain flag. + + """ + drain_flag = params[0] + return backend.JobQueueSetDrainFlag(drain_flag) + + + # hypervisor --------------- + + @staticmethod + def perspective_hypervisor_validate_params(params): + """Validate the hypervisor parameters. + + """ + (hvname, hvparams) = params + return backend.ValidateHVParams(hvname, hvparams) def ParseOptions(): """Parse the command line options. - Returns: - (options, args) as from OptionParser.parse_args() + @return: (options, args) as from OptionParser.parse_args() """ parser = OptionParser(description="Ganeti node daemon", - usage="%prog [-f] [-d]", + usage="%prog [-f] [-d] [-b ADDRESS]", version="%%prog (ganeti) %s" % constants.RELEASE_VERSION) @@ -310,92 +741,70 @@ def ParseOptions(): parser.add_option("-d", "--debug", dest="debug", help="Enable some debug messages", default=False, action="store_true") + parser.add_option("-b", "--bind", dest="bind_address", + help="Bind address", + default="", metavar="ADDRESS") + options, args = parser.parse_args() return options, args def main(): + """Main function for the node daemon. + + """ + global queue_lock + options, args = ParseOptions() + utils.debug = options.debug + + if options.fork: + utils.CloseFDs() + for fname in (constants.SSL_CERT_FILE,): if not os.path.isfile(fname): print "config %s not there, will not run." % fname sys.exit(5) try: - ss = ssconf.SimpleStore() - port = ss.GetNodeDaemonPort() - pwdata = ss.GetNodeDaemonPassword() + port = utils.GetNodeDaemonPort() except errors.ConfigurationError, err: print "Cluster configuration incomplete: '%s'" % str(err) sys.exit(5) + dirs = [(val, constants.RUN_DIRS_MODE) for val in constants.SUB_RUN_DIRS] + dirs.append((constants.LOG_OS_DIR, 0750)) + dirs.append((constants.LOCK_DIR, 1777)) + utils.EnsureDirs(dirs) + # become a daemon if options.fork: - createDaemon() + utils.Daemonize(logfile=constants.LOG_NODESERVER) - logger.SetupLogging(twisted_workaround=True, debug=options.debug, - program="ganeti-noded") + utils.WritePidFile(constants.NODED_PID) + try: + utils.SetupLogging(logfile=constants.LOG_NODESERVER, debug=options.debug, + stderr_logging=not options.fork) + logging.info("ganeti node daemon startup") - p = portal.Portal(MyRealm()) - p.registerChecker( - checkers.InMemoryUsernamePasswordDatabaseDontUse(master_node=pwdata)) - reactor.listenSSL(port, pb.PBServerFactory(p), ServerContextFactory()) - reactor.run() + # 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) -def createDaemon(): - """Detach a process from the controlling terminal and run it in the - background as a daemon. - """ - UMASK = 077 - WORKDIR = "/" - # Default maximum for the number of available file descriptors. - if 'SC_OPEN_MAX' in os.sysconf_names: - try: - MAXFD = os.sysconf('SC_OPEN_MAX') - if MAXFD < 0: - MAXFD = 1024 - except OSError: - MAXFD = 1024 - else: - MAXFD = 1024 - # The standard I/O file descriptors are redirected to /dev/null by default. - #REDIRECT_TO = getattr(os, "devnull", "/dev/null") - REDIRECT_TO = constants.LOG_NODESERVER - try: - pid = os.fork() - except OSError, e: - raise Exception, "%s [%d]" % (e.strerror, e.errno) - if (pid == 0): # The first child. - os.setsid() - try: - pid = os.fork() # Fork a second child. - except OSError, e: - raise Exception, "%s [%d]" % (e.strerror, e.errno) - if (pid == 0): # The second child. - os.chdir(WORKDIR) - os.umask(UMASK) - else: - # exit() or _exit()? See below. - os._exit(0) # Exit parent (the first child) of the second child. - else: - os._exit(0) # Exit parent of the first child. - maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1] - if (maxfd == resource.RLIM_INFINITY): - maxfd = MAXFD - - # Iterate through and close all file descriptors. - for fd in range(0, maxfd): + mainloop = daemon.Mainloop() + server = NodeHttpServer(mainloop, options.bind_address, port, + ssl_params=ssl_params, ssl_verify_peer=True) + server.Start() try: - os.close(fd) - except OSError: # ERROR, fd wasn't open to begin with (ignored) - pass - os.open(REDIRECT_TO, os.O_RDWR|os.O_CREAT|os.O_APPEND) # standard input (0) - # Duplicate standard input to standard output and standard error. - os.dup2(0, 1) # standard output (1) - os.dup2(0, 2) # standard error (2) - return(0) + mainloop.Run() + finally: + server.Stop() + finally: + utils.RemovePidFile(constants.NODED_PID) -if __name__=='__main__': +if __name__ == '__main__': main()