def save(model, timings, post_fix=""):
    print "Saving the model..."

    # ignore keyboard interrupt while saving
    start = time.time()
    s = signal.signal(signal.SIGINT, signal.SIG_IGN)

    model.save(
        model.state["save_dir"] + "/" + model.state["run_id"] + "_" + model.state["prefix"] + post_fix + "model.npz"
    )
    cPickle.dump(
        model.state,
        open(
            model.state["save_dir"]
            + "/"
            + model.state["run_id"]
            + "_"
            + model.state["prefix"]
            + post_fix
            + "state.pkl",
            "w",
        ),
    )
    numpy.savez(
        model.state["save_dir"] + "/" + model.state["run_id"] + "_" + model.state["prefix"] + post_fix + "timing.npz",
        **timings
    )
    signal.signal(signal.SIGINT, s)

    print "Model saved, took {}".format(time.time() - start)

def embeded_window():
	""" Create Gtk.Plug widget
	"""
	
	window_id = 0
	plug = Gtk.Plug(window_id)
	
	#FIXME
	print plug.get_id()
	
	builder = Gtk.Builder()
	builder.add_from_file(dirname + '/data/ui/blivet-gui.ui')

	signal.signal(signal.SIGINT, signal.SIG_DFL)

	vbox = builder.get_object("vbox")
	vbox.reparent(plug)

	dlist = ListDevices(builder)

	builder.get_object("disks_viewport").add(dlist.get_disks_view())

	builder.get_object("partitions_viewport").add(dlist.return_partitions_view())

	builder.get_object("actions_viewport").add(dlist.return_actions_view())

	builder.get_object("image_window").add(dlist.return_partitions_image())

	builder.get_object("vbox").add(dlist.get_partions_list().get_toolbar)
	
	return plug

 def register_signal(self, signum, callback):
     """callback signature: (signum)"""
     if signum not in self._signal_handlers:
         self._signal_handlers[signum] = [callback]
         signal.signal(signum, self._generic_signal_handler)
     else:
         self._signal_handlers[signum].append(callback)

def build(args):
    """ the entry point for all build subcommand tasks """
    builder = None
    fail = False
    try:
        manifest = None

        with open(args.manifest, 'r') as fh:
            manifest = fh.read()

        buildspec = BuildSpec(manifest, args.version, args.type, args.parallel,
                              args.projects)
        builder = BuilderFactory.create_builder(args.type, buildspec)

        def _signal_handler(*args):
            LOG.info("Process interrrupted. Cleaning up.")
            builder.cleanup()
            sys.exit()
        signal.signal(signal.SIGINT, _signal_handler)

        rc = builder.build()
    except Exception as e:
        LOG.exception("Oops something went wrong: %s", e)
        fail = True

    builder.cleanup()
    if fail:
        sys.exit(-1)
    sys.exit(rc)

def daemonize( errfile ):
    """
    Detach process and become a daemon.
    """
    pid = os.fork()
    if pid:
        os._exit(0)

    os.setsid()
    signal.signal(signal.SIGHUP, signal.SIG_IGN)
    os.umask(0)

    pid = os.fork()
    if pid:
        os._exit(0)

    os.chdir("/")
    for fd in range(0,20):
        try:
            os.close(fd)
        except OSError:
            pass

    sys.stdin = open("/dev/null","r")
    sys.stdout = open("/dev/null","w")
    sys.stderr = ErrorLog( errfile )

    def __init__(self, prompt="> ", stdin=None, stdout=None):
        if _debug: ConsoleCmd._debug("__init__")
        cmd.Cmd.__init__(self, stdin=stdin, stdout=stdout)
        Thread.__init__(self, name="ConsoleCmd")

        # check to see if this is running interactive
        self.interactive = sys.__stdin__.isatty()

        # save the prompt for interactive sessions, otherwise be quiet
        if self.interactive:
            self.prompt = prompt
        else:
            self.prompt = ''

        # gc counters
        self.type2count = {}
        self.type2all = {}

        # logging handlers
        self.handlers = {}

        # set a INT signal handler, ^C will only get sent to the
        # main thread and there's no way to break the readline
        # call initiated by this thread - sigh
        if hasattr(signal, 'SIGINT'):
            signal.signal(signal.SIGINT, console_interrupt)

        # start the thread
        self.start()

    def serve_forever(self):
        """ Accepts connection from multiple clients.
        """
        # register SIGTERM for graceful exit.
        def stop_gracefully(signum, frame):
            self.stop_server()
        
        signal.signal(signal.SIGINT, stop_gracefully)

        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.bind(self.addr)
        log.debug('%s listening on %s' % (type(self).__name__, self.addr))

        # start listening on this port
        sock.listen(5)
        # sock.setblocking(0)

        # spawn worker processes
        self.spawn_worker_processes()

        try:
            while True:
                # start accepting connections
                log.debug('Main: Waiting for incoming connections')
                connection, address = sock.accept()
                # connection.setblocking(0)

                serialized_socket = reduce_handle(connection.fileno())
                self.conn_queue.put(serialized_socket)
        except socket.error:
            log.warning('Interrupt: Stopping main process')
            self.stop_server()
        finally:
            sock.close()

    def run(self):
        """Runs the handler, flushes the streams, and ends the request."""
        # If there is a timeout
        if self._timeout:
            old_alarm = signal.signal(signal.SIGALRM, self.timeout_handler)
            signal.alarm(self._timeout)
            
        try:
            protocolStatus, appStatus = self.server.handler(self)
        except:
            traceback.print_exc(file=self.stderr)
            self.stderr.flush()
            if not self.stdout.dataWritten:
                self.server.error(self)

            protocolStatus, appStatus = FCGI_REQUEST_COMPLETE, 0

        if __debug__: _debug(1, 'protocolStatus = %d, appStatus = %d' %
                             (protocolStatus, appStatus))

        # Restore old handler if timeout was given
        if self._timeout:
            signal.alarm(0)
            signal.signal(signal.SIGALRM, old_alarm)

        try:
            self._flush()
            self._end(appStatus, protocolStatus)
        except socket.error, e:
            if e[0] != errno.EPIPE:
                raise

    def _install_signal_handlers(self):
        """Installs signal handlers for handling SIGINT and SIGTERM
        gracefully.
        """

        signal.signal(signal.SIGINT, self.request_stop)
        signal.signal(signal.SIGTERM, self.request_stop)

  def __init__(self, signum, handler_fn=None, wakeup=None):
    """Constructs a new SignalHandler instance.

    @type signum: int or list of ints
    @param signum: Single signal number or set of signal numbers
    @type handler_fn: callable
    @param handler_fn: Signal handling function

    """
    assert handler_fn is None or callable(handler_fn)

    self.signum = set(signum)
    self.called = False

    self._handler_fn = handler_fn
    self._wakeup = wakeup

    self._previous = {}
    try:
      for signum in self.signum:
        # Setup handler
        prev_handler = signal.signal(signum, self._HandleSignal)
        try:
          self._previous[signum] = prev_handler
        except:
          # Restore previous handler
          signal.signal(signum, prev_handler)
          raise
    except:
      # Reset all handlers
      self.Reset()
      # Here we have a race condition: a handler may have already been called,
      # but there's not much we can do about it at this point.
      raise

def _paramiko_tunnel(lport, rport, server, remoteip, keyfile=None, password=None):
    """Function for actually starting a paramiko tunnel, to be passed
    to multiprocessing.Process(target=this), and not called directly.
    """
    username, server, port = _split_server(server)
    client = paramiko.SSHClient()
    client.load_system_host_keys()
    client.set_missing_host_key_policy(paramiko.WarningPolicy())

    try:
        client.connect(server, port, username=username, key_filename=keyfile,
                       look_for_keys=True, password=password)
#    except paramiko.AuthenticationException:
#        if password is None:
#            password = getpass("%[email protected]%s's password: "%(username, server))
#            client.connect(server, port, username=username, password=password)
#        else:
#            raise
    except Exception as e:
        print ('*** Failed to connect to %s:%d: %r' % (server, port, e))
        sys.exit(1)
    
    # Don't let SIGINT kill the tunnel subprocess
    signal.signal(signal.SIGINT, signal.SIG_IGN)
    
    try:
        forward_tunnel(lport, remoteip, rport, client.get_transport())
    except KeyboardInterrupt:
        print ('SIGINT: Port forwarding stopped cleanly')
        sys.exit(0)
    except Exception as e:
        print ("Port forwarding stopped uncleanly: %s"%e)
        sys.exit(255)

 def _daemonize(self):
     if not self.config.NODETACH:
         # fork so the parent can exist
         if os.fork():
             return -1
         # deconnect from tty and create a new session
         os.setsid()
         # fork again so the parent, (the session group leader), can exit.
         # as a non-session group leader, we can never regain a controlling
         # terminal.
         if os.fork():
             return -1
         # move to the root to avoit mount pb
         os.chdir("/")
         # set paranoid umask
         os.umask(0o77)
         # write pid in a file
         f = open(self._pid_file, "w")
         f.write(str(os.getpid()))
         f.close()
         # close standard descriptors
         sys.stdin.close()
         sys.stdout.close()
         sys.stderr.close()
         # put signal handler
         signal.signal(signal.SIGTERM, self.signal_handler)
         signal.signal(signal.SIGHUP, self.signal_handler)

def main(argv):
    global command
    try:
        opts, args = getopt.getopt(argv, "sari:t:", ["sort", "rand", "rev", "item", "test"])
    except getopt.GetoptError:
        err()

    a = ["sort", "rand", "rev"]
    i = 1
    test = "100"
    for opt, arg in opts:
        if opt == "-u":
            err()
        elif opt in ("-s", "sort"):
            command = "sort"
        elif opt in ("-a", "random"):
            command = "rand"
        elif opt in ("-r", "reversed"):
            command = "rev"
        elif opt in ("-i", "item"):
            i = int(arg)
        elif opt in ("-t", "test"):
            test = arg
        else:
            err()
    atexit.register(exit, (test))
    signal.signal(signal.SIGTERM,exit)
    run(i, test)

    def remove_signal_handler(self, sig):
        """Remove a handler for a signal.  UNIX only.

        Return True if a signal handler was removed, False if not.
        """
        self._check_signal(sig)
        try:
            del self._signal_handlers[sig]
        except KeyError:
            return False

        if sig == signal.SIGINT:
            handler = signal.default_int_handler
        else:
            handler = signal.SIG_DFL

        try:
            signal.signal(sig, handler)
        except OSError as exc:
            if exc.errno == errno.EINVAL:
                raise RuntimeError('sig {} cannot be caught'.format(sig))
            else:
                raise

        if not self._signal_handlers:
            try:
                signal.set_wakeup_fd(-1)
            except (ValueError, OSError) as exc:
                logger.info('set_wakeup_fd(-1) failed: %s', exc)

        return True

def main():
    # Instantiate the Infrared-Thermopile Sensor on I2C on bus 1
    mySensor = TMP006.TMP006(1)

    ## Exit handlers ##
    # This stops python from printing a stacktrace when you hit control-C
    def SIGINTHandler(signum, frame):
        raise SystemExit

    # This lets you run code on exit,
    # including functions from mySensor
    def exitHandler():
        print("Exiting")
        sys.exit(0)

    # Register exit handlers
    atexit.register(exitHandler)
    signal.signal(signal.SIGINT, SIGINTHandler)

    # activate periodic measurements
    mySensor.setActive();

    # Print out temperature value and config-reg in hex every 0.5 seconds
    while(1):
        mySensor.getTemperature(True)
        hex(mySensor.getConfig())

        time.sleep(.5)

	def __init__ (self,configuration):
		self.ip = environment.settings().tcp.bind
		self.port = environment.settings().tcp.port

		self.max_loop_time = environment.settings().reactor.speed
		self.half_loop_time = self.max_loop_time / 2

		self.logger = Logger()
		self.daemon = Daemon(self)
		self.processes = None
		self.listener = None
		self.configuration = Configuration(configuration)

		self._peers = {}
		self._shutdown = False
		self._reload = False
		self._reload_processes = False
		self._restart = False
		self._route_update = False
		self._saved_pid = False
		self._commands = []
		self._pending = []

		signal.signal(signal.SIGTERM, self.sigterm)
		signal.signal(signal.SIGHUP, self.sighup)
		signal.signal(signal.SIGALRM, self.sigalrm)
		signal.signal(signal.SIGUSR1, self.sigusr1)
		signal.signal(signal.SIGUSR2, self.sigusr2)

def main():
  signal.signal(signal.SIGUSR1, DumpThreadStacks)

  parser = argparse.ArgumentParser()
  command_parsers = parser.add_subparsers(title='test types',
                                          dest='command')

  for test_type, config in sorted(VALID_COMMANDS.iteritems(),
                                  key=lambda x: x[0]):
    subparser = command_parsers.add_parser(
        test_type, usage='%(prog)s [options]', help=config.help_txt)
    config.add_options_func(subparser)

  args = parser.parse_args()

  try:
    return RunTestsCommand(args, parser)
  except base_error.BaseError as e:
    logging.exception('Error occurred.')
    if e.is_infra_error:
      return constants.INFRA_EXIT_CODE
    return constants.ERROR_EXIT_CODE
  except: # pylint: disable=W0702
    logging.exception('Unrecognized error occurred.')
    return constants.ERROR_EXIT_CODE

 def wait_for_keyboard(self):
     """quit when press q or press ctrl-c, or exception from other threads"""
     try:
         while True:
             time.sleep(2)   # 减少死锁概率
             print("enter 'q' to quit, 'r' to reload, 'l' to list ports.")
             key = input().lower().strip()
             if key == 'q':
                 break
             elif key == 'r':
                 log.info('main: reload config.')
                 self.start_threads_from_config()
             elif key == 'l':
                 try:
                     print('name, station_port, dispatch_port, control_port')
                     for name, config in sorted(self.configs['entry'].items()):
                         control_port = str(config['controlPort']) if 'controlPort' in config else None
                         print('%s, %d, %d, %s'
                               % (name, config['stationPort'], config['listenPort'], control_port))
                 except Exception as e:
                     print('Error when list config: %s' % e)
     except KeyboardInterrupt:
         pass
     except (EOFError, OSError):
         # no input
         signal.signal(signal.SIGINT, self.exit_by_signal)
         signal.signal(signal.SIGTERM, self.exit_by_signal)
         while not self.is_interrupt:
             time.sleep(1)

def ignore_sigint():
    """Ignore SIGINT for the duration."""
    old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
    try:
        yield
    finally:
        signal.signal(signal.SIGINT, old_handler)

def main():

    # Default subnet is required for the host tracker to work.
    subnet_control = SubnetControl()
    subnet_control.list()
    subnet_control.add_subnet("defaultSubnet", "10.0.0.254/8")

    raw_input("[Press enter when mininet is ready] ")
    print("-------------------------")

    # Add per-protocol flows so we can monitor stats that way
    x = analytics.add_protocol_flows()
    if (not x):
        print "Unable to add per-protocol flows"

    m = WaypointMonitor(Stats.TYPE_SUBNET, subnet="10.0.0.1/32")
    m.set_waypoint("10.0.0.2")
    m.set_large_flow_threshold(2000) # 2000 bytes
    m.start()

    # Register signal-handler to catch SIG_INT
    signal.signal(signal.SIGINT, signal_handler)
    signal.pause()

    # join() won't return until SIG_INT has been captured
    m.join()