def main():
    args = _get_args()
    mkdirp(conf.get_opt("session_dir"), exit_on_err=True)

    if args.mode == "list":
        session_dir = conf.get_opt("session_dir")
    else:
        session_dir = os.path.join(conf.get_opt("session_dir"),
                                   args.session)

    if not os.path.exists(session_dir) and args.mode not in ["create", "list"]:
        fail("Invalid session %s" % args.session)

    vol_dir = os.path.join(session_dir, args.volume)
    if not os.path.exists(vol_dir) and args.mode not in ["create", "list"]:
        fail("Session %s not created with volume %s" %
            (args.session, args.volume))

    mkdirp(os.path.join(conf.get_opt("log_dir"), args.session, args.volume),
           exit_on_err=True)
    log_file = os.path.join(conf.get_opt("log_dir"),
                            args.session,
                            args.volume,
                            "cli.log")
    setup_logger(logger, log_file, args.debug)

    # globals() will have all the functions already defined.
    # mode_<args.mode> will be the function name to be called
    globals()["mode_" + args.mode](session_dir, args)

def main(argv):
    """
    Entry point for etl module.
    """
    option_parser = optparse.OptionParser(usage=DEFAULT_USAGE_TEXT)
    option_parser.add_option("-c", "--config", dest="config",
                             default="config.cfg", help="Configuration file")
    option_parser.add_option("-v", "--verbose", dest="verbose",
                             action="store_true", default=False,
                             help="Show verbose output")
    options, _ = option_parser.parse_args(argv)

    if not os.path.exists(options.config):
        sys.stderr.write("ERROR: {} does not exist\n".format(options.config))
        option_parser.print_help()
        return 1
    config = read_config(options.config)

    log_dir = config['general']['log_dir']
    if not os.path.exists(log_dir):
        os.mkdir(log_dir)
    filename = os.path.join(log_dir, __file__.replace(".py", ".log"))
    setup_logger(filename, options.verbose)
    logging.debug("config={}".format(json.dumps(config, indent=2)))

    retcode = run_etl(config)
    return retcode

def main():
    global gtmpfilename

    args = None

    try:
        args = _get_args()
        mkdirp(conf.get_opt("session_dir"), exit_on_err=True)

        # force the default session name if mode is "query"
        if args.mode == "query":
            args.session = "default"

        if args.mode == "list":
            session_dir = conf.get_opt("session_dir")
        else:
            session_dir = os.path.join(conf.get_opt("session_dir"),
                                       args.session)

        if not os.path.exists(session_dir) and \
                args.mode not in ["create", "list", "query"]:
            fail("Invalid session %s" % args.session)

        # "default" is a system defined session name
        if args.mode in ["create", "post", "pre", "delete"] and \
                args.session == "default":
            fail("Invalid session %s" % args.session)

        vol_dir = os.path.join(session_dir, args.volume)
        if not os.path.exists(vol_dir) and args.mode not in \
                ["create", "list", "query"]:
            fail("Session %s not created with volume %s" %
                 (args.session, args.volume))

        mkdirp(os.path.join(conf.get_opt("log_dir"),
                            args.session,
                            args.volume),
               exit_on_err=True)
        log_file = os.path.join(conf.get_opt("log_dir"),
                                args.session,
                                args.volume,
                                "cli.log")
        setup_logger(logger, log_file, args.debug)

        # globals() will have all the functions already defined.
        # mode_<args.mode> will be the function name to be called
        globals()["mode_" + args.mode](session_dir, args)
    except KeyboardInterrupt:
        if args is not None:
            if args.mode == "pre" or args.mode == "query":
                # cleanup session
                if gtmpfilename is not None:
                    # no more interrupts until we clean up
                    signal.signal(signal.SIGINT, signal.SIG_IGN)
                    run_cmd_nodes("cleanup", args, tmpfilename=gtmpfilename)

        # Interrupted, exit with non zero error code
        sys.exit(2)

def init_event_server():
    utils.setup_logger()

    # Delete Socket file if Exists
    try:
        os.unlink(SERVER_ADDRESS)
    except OSError:
        if os.path.exists(SERVER_ADDRESS):
            print ("Failed to cleanup socket file {0}".format(SERVER_ADDRESS),
                   file=sys.stderr)
            sys.exit(1)

    utils.load_all()

    # Start the Eventing Server, UNIX DOMAIN SOCKET Server
    GlusterEventsServer()
    asyncore.loop()

def init_event_server():
    utils.setup_logger()
    utils.load_all()

    port = utils.get_config("port")
    if port is None:
        sys.stderr.write("Unable to get Port details from Config\n")
        sys.exit(1)

    # Start the Eventing Server, UDP Server
    try:
        server = SocketServer.ThreadingUDPServer(
            (SERVER_ADDRESS, port),
            GlusterEventsRequestHandler)
    except socket.error as e:
        sys.stderr.write("Failed to start Eventsd: {0}\n".format(e))
        sys.exit(1)
    server.serve_forever()

def mode_cleanup(args):
    working_dir = os.path.join(conf.get_opt("working_dir"),
                               args.session,
                               args.volume)

    mkdirp(os.path.join(conf.get_opt("log_dir"), args.session, args.volume),
           exit_on_err=True)
    log_file = os.path.join(conf.get_opt("log_dir"),
                            args.session,
                            args.volume,
                            "changelog.log")

    setup_logger(logger, log_file)

    try:
        shutil.rmtree(working_dir, onerror=handle_rm_error)
    except (OSError, IOError) as e:
        logger.error("Failed to delete working directory: %s" % e)
        sys.exit(1)

    def __init__(self):
        print "starting server"
        self.key = '' # generate public/private key
        self.peers = {}
        self.p2pfiles = []  # list of P2PFile
        self.server_id = os.urandom(8).encode('hex')
        self.max_peer_sem = threading.Semaphore(MAX_PEERS)   # This is to control shard serving requests
        self._load_files()  # load metadata and create dirs
        self.logger = utils.setup_logger(LOG_FILE)  # setup logger
        self._load_keys()   # load publickey

        self.heartbeat_thrd = threading.Timer(HEARTBEAT_TIMEOUT, self.check_clients) #Thread to monitor alive peers
        self.heartbeat_thrd.setDaemon(True)
        self.heartbeat_thrd.start()

    def __init__(self, ec2, ec2_client, tag_base_name, **kwargs):
        """Constructor

        Args:
            ec2 (object): Aws Ec2 session
            ec2_client (object): Aws ec2 session
            tag_base_name (string): Tag base name
            **kwargs: Multiple arguments

        Raises:
            TypeError: Description
        """
        BaseResources.__init__(self, ec2, ec2_client, tag_base_name)
        log_level = kwargs.pop("log_level", logging.WARNING)
        boto_log_level = kwargs.pop("boto_log_level", logging.WARNING)

        if kwargs:
            raise TypeError("Unexpected **kwargs: %r" % kwargs)
        self.logger = setup_logger(__name__, log_level, boto_log_level)

def main():
    parser = argparse.ArgumentParser(
        description='pyrasite - inject code into a running python process',
        epilog="For updates, visit https://github.com/lmacken/pyrasite"
        )
    parser.add_argument('pid',
                        help="The ID of the process to inject code into")
    parser.add_argument('filename',
                        help="The second argument must be a filename")
    parser.add_argument('--gdb-prefix', dest='gdb_prefix',
                        help='GDB prefix (if specified during installation)',
                        default="")
    parser.add_argument('--verbose', dest='verbose', help='Verbose mode',
                        default=False, action='store_const', const=True)

    if len(sys.argv) == 1:
        parser.print_help()
        sys.exit(1)

    args = parser.parse_args()

    log = setup_logger()

    try:
        pid = int(args.pid)
    except ValueError:
        log.error("Error: The first argument must be a pid")
        sys.exit(2)

    filename = args.filename
    if filename:
        if not os.path.exists(filename):
            log.error("Error: Invalid path or file doesn't exist")
            sys.exit(3)
    else:
        log.error("Error: The second argument must be a filename")
        sys.exit(4)

    injector = CodeInjector(pid, verbose=args.verbose,
                            gdb_prefix=args.gdb_prefix)
    injector.inject(filename)

    def __init__(self):
        print "Client running at: %s" % str(LOCAL_ADDRESS)
        self.server_key = '' # server's public key
        self.current_peers = {} # current active peers
        self.peer_times = {}
        self.p2pfiles = []  # list of p2p files
        self.shards = []    # list of shards 
        self.peer_id = None
        self.max_peer_sem = threading.Semaphore(MAX_PEERS)   # This is to control shard serving requests
        self._load_files()
        self.logger = utils.setup_logger(LOG_FILE)
        self._reg_with_server()

        self.ping_thrd = threading.Timer(1.0, self._ping_server_thread)
        self.ping_thrd.setDaemon(True)
        self.ping_thrd.start()
        
        self.peer_thrd = threading.Timer(1.0, self._peer_contact_thread)
        self.peer_thrd.setDaemon(True)
        self.peer_thrd.start()

        self.timeout_thrd = threading.Timer(1.0, self._peer_timeout_thread)
        self.timeout_thrd.setDaemon(True)
        self.timeout_thrd.start()

__date__ = "30/07/2012"
__copyright__ = "Copyright 2012, Australia Indonesia Facility for " "Disaster Reduction"

import os
import sys
import logging
from urllib2 import URLError
from zipfile import BadZipfile

from ftp_client import FtpClient
from sftp_client import SFtpClient
from utils import setup_logger, data_dir, is_event_id
from shake_event import ShakeEvent

# Loading from package __init__ not working in this context so manually doing
setup_logger()
LOGGER = logging.getLogger("InaSAFE")


def process_event(event_id=None, locale="en"):
    """Launcher that actually runs the event processing.

    :param event_id: The event id to process. If None the latest event will
       be downloaded and processed.
    :type event_id: str

    :param locale: The locale that will be used. Default to en.
    :type locale: str
    """
    population_path = os.path.join(data_dir(), "exposure", "IDN_mosaic", "popmap10_all.tif")

def main(argv):
    """
    Entry point for chart generation.
    """
    option_parser = optparse.OptionParser(usage=DEFAULT_USAGE_TEXT)
    option_parser.add_option("-c", "--config", dest="config",
                             default="config.cfg", help="Configuration file")
    option_parser.add_option("-v", "--verbose", dest="verbose",
                             action="store_true", default=False,
                             help="Show verbose output")

    option_parser.add_option("-x", "--x_axis", type="choice",
                             choices=[TIME],
                             help="Label for x-axis: time")

    option_parser.add_option("-X", "--x_output", dest="x_output",
                             help="Unit for x-axis. "
                             "time: daily, month, yearly or range 2000,2003. "
                             "Range for time is separated by comma to allow "
                             "daily range such as -X 2000-01-01,2003-08-20")

    option_parser.add_option("-y", "--y_axis", type="choice",
                             choices=[SALARY],
                             help="Label for y-axis: salary")

    option_parser.add_option("-Y", "--y_output", type="choice",
                             choices=[MEDIAN, TOTAL],
                             help="Unit for y-axis. salary: median or total")

    option_parser.add_option("-d", "--data_type", type="choice",
                             choices=[AGE, COMPANY, GENDER, JOBROLE, MANAGER],
                             help="Data type for plotted lines: "
                             "age, company, gender, jobrole or manager")

    option_parser.add_option("-D", "--data_output", dest="data_output",
                             help="Unit for plotted lines. "
                             "age: comma-separated list of ages or ranges, "
                             "company: comma-separated list of IDs, "
                             "gender: comma-separated list (male,female, "
                             "undefined or empty for all), "
                             "jobrole: comma-separated list of job roles, "
                             "manager: comma-separated list (true,false)")

    options, _ = option_parser.parse_args(argv)
    error = ""
    if not options.x_axis:
        error = "--x_axis is required"
    if not options.x_output:
        error = "--x_output is required"
    if not options.y_axis:
        error = "--y_axis is required"
    if not options.y_output:
        error = "--y_output is required"
    if not options.data_type:
        error = "--data_type is required"
    if not options.data_output:
        error = "--data_output is required"
    if error:
        sys.stderr.write("ERROR: {}\n".format(error))
        option_parser.print_help()
        return 1

    if not os.path.exists(options.config):
        sys.stderr.write("ERROR: {} does not exist\n".format(options.config))
        option_parser.print_help()
        return 1
    config = read_config(options.config)

    log_dir = config['general']['log_dir']
    if not os.path.exists(log_dir):
        os.mkdir(log_dir)
    filename = os.path.join(log_dir, __file__.replace(".py", ".log"))
    setup_logger(filename, options.verbose)
    logging.debug("config={}".format(json.dumps(config, indent=2)))

    retcode = generate_chart(config, options)
    return retcode

def main(sim_dir, proc_time, num_jobs, jobs_per, in_gb, out_gb, out_gb_dl,
         up_rate, down_rate, bid_ratio, instance_type, av_zone, product,
         csv_file=None):
    '''
    Function to calculate spot instance run statistics based on job
    submission parameters; this function will save the statistics and
    specific spot history in csv dataframes to execution directory

    Parameters
    ----------
    sim_dir : string
        base directory where to create the availability zone folders
        for storing the simulation results
    proc_time : float
        the number of minutes a single job of interest takes to run
    num_jobs : integer
        total number of jobs to run to complete job submission
    jobs_per : integer
        the number of jobs to run per node
    in_gb : float
        the total amount of input data for a particular job (in GB)
    out_gb : float
        the total amount of output data from a particular job (in GB)
    out_gb_dl : float
        the total amount of output data to download from EC2 (in GB)
    up_rate : float
        the average upload rate to transfer data to EC2 (in Mb/s)
    down_rate : float
        the average download rate to transfer data from EC2 (in Mb/s)
    bid_ratio : float
        the ratio to average spot history price to set the bid price to
    instance_type : string
        type of instance to run the jobs on and to get spot history for
    av_zone : string
        the AWS EC2 availability zone (sub-region) to get spot history
        from
    product : string
        the type of operating system product to get spot history for
    csv_file : string (optional), default is None
        the filepath to a csv dataframe to get spot history from;
        if not specified, the function will just get the most recent 90
        days worth of spot price history

    Returns
    -------
    spot_history : pd.DataFrame object
        in addition to saving this as './spot_history.csv' the
        dataframe can also be returned as an object in memory
    stat_df : pd.DataFrame object
        in addition to saving this as './<info>_stats.csv' the
        dataframe can also be returned as an object in memory
    '''

    # Import packages
    import dateutil
    import logging
    import numpy as np
    import os
    import pandas as pd
    import yaml

    # Import local packages
    import utils
    from record_spot_price import return_spot_history

    # Init variables
    proc_time *= 60.0
    num_nodes = min(np.ceil(float(num_jobs)/jobs_per), 20)

    # Init simulation market results dataframe
    sim_df_cols = ['start_time', 'spot_hist_csv', 'proc_time', 'num_datasets',
                   'jobs_per_node', 'num_jobs_iter', 'bid_ratio', 'bid_price',
                   'median_history', 'mean_history', 'stdev_history',
                   'compute_time', 'wait_time', 'per_node_cost',
                   'num_interrupts', 'first_iter_time']
    sim_df = pd.DataFrame(columns=sim_df_cols)

    # Init full run stats data frame
    stat_df_cols = ['Total cost', 'Instance cost', 'Storage cost', 'Tranfer cost',
                    'Total time', 'Run time', 'Wait time',
                    'Upload time', 'Download time']
    stat_df = pd.DataFrame(columns=stat_df_cols)

    # Set up logger
    base_dir = os.path.join(sim_dir, av_zone)
    if not os.path.exists(base_dir):
        try:
            os.makedirs(base_dir)
        except OSError as exc:
            print 'Found av zone directory %s, continuing...' % av_zone
    log_path = os.path.join(base_dir, '%s_%d-jobs_%.3f-bid.log' % \
                            (instance_type, num_jobs, bid_ratio))
    stat_log = utils.setup_logger('stat_log', log_path, logging.INFO, to_screen=True)

    # Check to see if simulation was already run (sim csv file exists)
    sim_csv = os.path.join(base_dir, '%s_%d-jobs_%.3f-bid_sim.csv' % \
                           (instance_type, num_jobs, bid_ratio))
    if os.path.exists(sim_csv):
        stat_log.info('Simulation file %s already exists, skipping...' % sim_csv)
        return
#.........这里部分代码省略.........

    opt.add_option('--dhcp-subnetmask', dest='dhcp_subnetmask', default=DHCP_DEFAULT_SUBNETMASK, action='store',
            help='DHCP lease subnet mask')
    opt.add_option('--dhcp-gateway', dest='dhcp_gateway', default=DHCP_DEFAULT_GW, action='store',
            help='DHCP lease gateway')
    opt.add_option('--dhcp-dns', dest='dhcp_dns', default=DHCP_DEFAULT_DNS, action='store',
            help='DHCP lease DNS')
    opt.add_option('--dhcp-bcast', dest='dhcp_bcast', default=DHCP_DEFAULT_BCAST, action='store',
            help='DHCP lease broadcast')
    opt.add_option('--dhcp-fileserver', dest='dhcp_fileserver', default='', action='store',
            help='DHCP lease fileserver IP (option 66)')
    opt.add_option('--dhcp-filename', dest='dhcp_filename', default='', action='store',
            help='DHCP lease filename (option 67)')

    options, args = opt.parse_args(sys.argv[1:])

    main_logger = utils.setup_logger('main_logger', options.logfile, options.debug)
    sip_logger = utils.setup_logger('sip_logger', options.sip_logfile, options.debug, str_format='%(asctime)s %(message)s')    
    
    main_logger.info("Starting application")
    
    main_logger.debug("SIP: Writing SIP messages in %s log file" % options.sip_logfile)
    main_logger.debug("SIP: Authentication password: %s" % options.sip_password)
    main_logger.debug("Logfile: %s" % options.logfile)
    
    if not options.terminal:
        import gui
        import Tkinter as tk

        root = tk.Tk()
        app = gui.MainApplication(root, options, main_logger)
        root.title(sys.argv[0])

    options.update({'test.save': os.path.join(sprefix, sfolder, 'test.save')})
    options.update({'params.save': os.path.join(sprefix, sfolder, 'params.save')})
    if not os.path.exists(os.path.join(sprefix, sfolder)):
        os.makedirs(os.path.join(sprefix, sfolder))

    # current word included
    train_set, test_set = load_cate_data(options)
    mlp = init_cate_params(options)
    run_cate(mlp, train_set, test_set, options)


if __name__ == "__main__":
    log_folder = '../log'
    main_file = 'main_log'
    correct_file = 'correct_log'
    error_file = 'error_log'
    main_name = 'main'
    corr_name = 'correct'
    error_name = 'error'

    stript_path = os.path.dirname(os.path.abspath(__file__))
    log_folder_path = os.path.join(stript_path, log_folder)
    if not os.path.exists(log_folder_path):
        os.makedirs(log_folder_path)
    log_file_names = (main_file, correct_file, error_file)
    logger_names = (main_name, corr_name, error_name)
    setup_logger(log_folder_path, log_file_names, logger_names)
    log_main = logging.getLogger(main_name)
    log_main.info('\n*****date: %s*****' % datetime.datetime.now())
    main()

    def handle(self):
        data = self.request[0]
        self.data = data.split("\r\n")
        self.socket = self.request[1]
        request_uri = self.data[0]
        if rx_request_uri.search(request_uri) or rx_code.search(request_uri):
            self.server.sip_logger.debug("Received from %s:%d (%d bytes):\n\n%s" %  (self.client_address[0], self.client_address[1], len(data), data))
            self.processRequest()
        else:
            if len(data) > 4:
                self.server.sip_logger.debug("Received from %s:%d (%d bytes):\n\n" %  (self.client_address[0], self.client_address[1], len(data)))
                mess = hexdump(data,' ',16)
                self.server.sip_logger.debug('PnP Hex data:\n' + '\n'.join(mess))

if __name__ == '__main__':
    import utils

    class Options:
        ip = "127.0.0.1"
        pnp_uri = "http://test.com"
    
    options = Options()
    
    HOST = "224.0.1.75"
    PORT = 5060
    main_logger = utils.setup_logger('main_logger', None, True)
    sip_logger = utils.setup_logger('sip_logger', None, True)

    pnp_server = SipTracedMcastUDPServer((HOST, PORT), UDPHandler, main_logger, sip_logger, options)
    pnp_server.serve_forever()

import os
import validictory

import utils

def run_main(main_func, schema, args):
	if len(args) < 2:
		print "Usage: " + args[0] + " <json config file>"
		print "For possible configs: " + args[0] + " help"
		sys.exit(1)
	if args[1].lower() in ["--h", "-h", "help", "-help", "--help"]:
		#pprint.pprint(schema)
		print json.dumps(schema, indent=2)
		sys.exit(0)

	arguments = {}
	for i in xrange(1, len(args)):
		try:
			config = args[i]
			print >> sys.stderr, "Merging %s into configuration" %(config,)
			arguments.update(json.load(open(config)))
		except Exception, e:
			print e
			sys.exit(1)

	validictory.validate(arguments, schema)
	logging_ini = None
	if "logging_ini" in arguments:
		logging_ini = arguments["logging_ini"]
	utils.setup_logger(logging_ini)
	main_func(arguments)

#.........这里部分代码省略.........
        tk.Label(self.settings_frame, text="DHCP Pool end:").grid(row=row, column=2, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_end, width=15).grid(row=row, column=3, sticky=tk.W)
        row = row + 1

        self.gui_dhcp_subnetmask = tk.StringVar()
        self.gui_dhcp_subnetmask.set(self.options.dhcp_subnetmask)
        tk.Label(self.settings_frame, text="DHCP Subnet mask:").grid(row=row, column=0, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_subnetmask, width=15).grid(row=row, column=1, sticky=tk.W)
        #row = row + 1

        self.gui_dhcp_gateway = tk.StringVar()
        self.gui_dhcp_gateway.set(self.options.dhcp_gateway)
        tk.Label(self.settings_frame, text="DHCP Gateway:").grid(row=row, column=2, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_gateway, width=15).grid(row=row, column=3, sticky=tk.W)
        row = row + 1

        self.gui_dhcp_bcast = tk.StringVar()
        self.gui_dhcp_bcast.set(self.options.dhcp_bcast)
        tk.Label(self.settings_frame, text="DHCP Broadcast:").grid(row=row, column=0, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_bcast, width=15).grid(row=row, column=1, sticky=tk.W)
        #row = row + 1

        self.gui_dhcp_dns = tk.StringVar()
        self.gui_dhcp_dns.set(self.options.dhcp_dns)
        tk.Label(self.settings_frame, text="DHCP DNS:").grid(row=row, column=2, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_dns, width=15).grid(row=row, column=3, sticky=tk.W)
        row = row + 1

        self.gui_dhcp_fileserver = tk.StringVar()
        self.gui_dhcp_fileserver.set(self.options.dhcp_fileserver)
        tk.Label(self.settings_frame, text="DHCP Fileserver (opt. 66):").grid(row=row, column=0, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_fileserver, width=25).grid(row=row, column=1, sticky=tk.W)
        #row = row + 1

        self.gui_dhcp_filename = tk.StringVar()
        self.gui_dhcp_filename.set(self.options.dhcp_filename)
        tk.Label(self.settings_frame, text="DHCP Filename (opt. 67):").grid(row=row, column=2, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_dhcp_filename, width=25).grid(row=row, column=3, sticky=tk.W)
        row = row + 1

        tk.Label(self.settings_frame, text="SIP Plug&Play:", font = "-weight bold").grid(row=row, column=0, sticky=tk.W)
        row = row + 1
        
        self.gui_pnp_uri = tk.StringVar()
        self.gui_pnp_uri.set(self.options.pnp_uri)
        tk.Label(self.settings_frame, text="PnP URI:").grid(row=row, column=0, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_pnp_uri, width=60).grid(row=row, column=1, columnspan=3, sticky=tk.W)
        row = row + 1
        
        tk.Label(self.settings_frame, text="SIP Proxy:", font = "-weight bold").grid(row=row, column=0, sticky=tk.W)
        row = row + 1
        
        self.gui_sip_redirect = tk.BooleanVar()
        self.gui_sip_redirect.set(self.options.sip_redirect)
        tk.Label(self.settings_frame, text="SIP Redirect server:").grid(row=row, column=0, sticky=tk.W)
        tk.Checkbutton(self.settings_frame, variable=self.gui_sip_redirect, command=self.gui_sip_redirect_action).grid(row=row, column=1, sticky=tk.W)
        #row = row + 1
        
        self.gui_sip_port = tk.IntVar()
        self.gui_sip_port.set(self.options.sip_port)
        tk.Label(self.settings_frame, text="SIP Port:").grid(row=row, column=2, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_sip_port, width=5).grid(row=row, column=3, sticky=tk.W)
        row = row + 1
 
        self.gui_sip_password = tk.StringVar()
        self.gui_sip_password.set(self.options.sip_password)
        tk.Label(self.settings_frame, text="Password:").grid(row=row, column=0, sticky=tk.W)
        tk.Entry(self.settings_frame, textvariable=self.gui_sip_password, width=15).grid(row=row, column=1, sticky=tk.W)
        row = row + 1
 
        self.sip_control_button = tk.Button(self.settings_frame, text="Start SIP Proxy", command=self.start_sip_proxy)
        self.sip_control_button.grid(row=row, column=0, sticky=tk.N)
        
        self.tftp_control_button = tk.Button(self.settings_frame, text="Start TFTP Server", command=self.start_tftp_server)
        self.tftp_control_button.grid(row=row, column=1, sticky=tk.N)
        
        self.http_control_button = tk.Button(self.settings_frame, text="Start HTTP Server", command=self.start_http_server)
        self.http_control_button.grid(row=row, column=2, sticky=tk.N)
        
        self.dhcp_control_button = tk.Button(self.settings_frame, text="Start DHCP Server", command=self.start_dhcp_server)
        self.dhcp_control_button.grid(row=row, column=3, sticky=tk.N)
        
        self.pnp_control_button = tk.Button(self.settings_frame, text="Start PnP Server", command=self.start_pnp_server)
        self.pnp_control_button.grid(row=row, column=4, sticky=tk.N)
        
        #self.registrar_button = tk.Button(self.settings_frame, text="Reload registered", command=self.load_registrar)
        #self.registrar_button.grid(row=row, column=4, sticky=tk.N)
        #row = row + 1
        
        #self.registrar_frame.grid(row=1, column=0, sticky=tk.NS)
        
        #self.registrar_text = ScrolledText(self.registrar_frame)
        #self.registrar_text.grid(row=0, column=0, sticky=tk.NS)
        #self.registrar_text.config(state='disabled') 
    
        self.sip_queue = Queue.Queue()
        self.sip_trace_logger = utils.setup_logger('sip_widget_logger', log_file=None, debug=True, str_format='%(asctime)s %(message)s', handler=SipTraceQueueLogger(queue=self.sip_queue))
    
        self.log_queue = Queue.Queue()
        utils.setup_logger('main_logger', options.logfile, self.options.debug, handler=MessagesQueueLogger(queue=self.log_queue))

    return celery

celery = make_celery(app)

# DB
db = MongoEngine()
db.init_app(app)
db_wrapper = Database(db, cfg)

if __name__ == '__main__':

    # TODO - not this
    __builtin__.flock_app = app

    # Logging
    setup_logger(cfg["logging"]["file"], cfg["logging"]["level"])

    # Init Rollbar
    @app.before_first_request
    def init_rollbar():
        rollbar.init(
            cfg["rollbar"]["token"],
            cfg["rollbar"]["environment"],
            root=os.path.dirname(os.path.realpath(__file__)),
            allow_logging_basic_config=False
        )
        got_request_exception.connect(rollbar.contrib.flask.report_exception, app)

    class CustomRequest(Request):
        @property
        def rollbar_person(self):

NUMBER_OF_ROWS = 10 ** 2
NUMBER_OF_COLS = 10
ROW_OFFSET = 2
COL_OFFSET = 2
VALUES_BUTTON_MAX_WIDTH = 50
VARIABLE_LIST_COLS_WIDTH = 50
VARIABLE_LIST_COL_N_WIDTH = 20
VARIABLE_LIST_COLS_COUNT = 6
N_ROLE = 0
NAME_ROLE = 1
TYPE_ROLE = 2
WIDTH_ROLE = 3
DECIMAL_ROLE = 4
LABEL_ROLE = 5

if __name__ == '__main__':
    sys.excepthook = handle_exception
    setup_logger("FS")
    app = QApplication(sys.argv)

    app.setStyle("Fusion")
    app.blockSignals(True)
    fill_random()
    app.blockSignals(False)

    window = MainWindow()
    window.show()

    exit_code = app.exec_()
    sys.exit(exit_code)