def test_parse_lines(self):
     sv = Server()
     sv.read_tag_file("./data") 
     sv.parse_lines()
     PARSED_LINE_SEQUENCE_LIST = [("a","B"),("b","B"),("c","I"),("d","B"), \
         ("e","I"),("f","I"),("",),("g","B"),("h","I"),("i","B")]
     self.assertEquals(PARSED_LINE_SEQUENCE_LIST, sv.parsed_line_sequence_list)

def main():
    main_server_instance = Server(HOST, user=USER, passwd=PASSWD, port=PORT, use_ssl=USE_SSL)
    manager = multiprocessing.Manager()
    lock = multiprocessing.Lock()

    for group in GROUPS:
        workers = []
        # get group info here.
        first, last, count = main_server_instance.set_group(group)

        start_index = multiprocessing.Value('i', last)
        results = manager.list()
        args = (HOST, USER, PASSWD, PORT, USE_SSL, group, start_index,
                CHUNK_SIZE, results, lock, first)

        for i in range(1, MAX_CONNECTIONS):
            p = multiprocessing.Process(target=article_worker, args=args)
            p.start()
            workers.append(p)

        try:
            for worker in workers:
                worker.join()
        except KeyboardInterrupt:
            for worker in workers:
                worker.terminate()
                worker.join()

        for worker in workers:
            worker.terminate()
            worker.join()

        print(first, start_index.value, last)

def main():
    #use argparse to get role, ip, port and user name
    parser = argparse.ArgumentParser(
        description="""PySyncIt""",
        formatter_class=argparse.RawDescriptionHelpFormatter)
    
    parser.add_argument(
        '-ip', help='Specify the ip address of this machine', required=True)

    parser.add_argument(
        '-port', help='Specify the port of this machine to run rpc server', required=True)

    parser.add_argument(
        '-uname', help='Specify the user name of this machine', required=True)
    
    parser.add_argument(
        '-role', help='Specify the role of this machine - client or server', required=True)
    
    args = parser.parse_args()

    #start logging
    setup_logging("syncit.log.%s-%s" % (args.ip, args.port));
    logger = logging.getLogger('syncIt')

    #Read config file
    config = ConfigParser.ConfigParser()
    logger.info("Using config file: syncit.cfg")
    config.read('syncit.cfg')

    if (args.role == 'server'):
        node = Server(args.role, args.ip, int(args.port), args.uname, get_watch_dirs(config, args.uname), get_clients(config))
    else:
        node = Client(args.role, args.ip, int(args.port), args.uname, get_watch_dirs(config, args.uname), get_server_tuple(config))

    node.activate()

 def _display_from_interpreter(self):
     server = Server(json=self.saved_json_file)
     print '''Your visualization is being rendered at
              http://localhost:%s/
              Visit the url in your webgl compatible browser
              to see the animation in full glory'''%(server.port)
     server.run()

def main():
	server = Server()

	title = "capton"
	mode = (600, 600, 0, 32)

	pygame.init()
	pygame.display.set_caption(title)
	screen = pygame.display.set_mode(mode[:2], mode[2], mode[3])

	client = Client()

#	ENTITY_COLOR = (255, 255, 255)
#	client.set_entity_color(ENTITY_COLOR)

	client.send_connect(server)

	I_COUNT = 30
	J_COUNT = 30
	FILL_PERCENT = 20
	client.send_create_random_world(I_COUNT, J_COUNT, FILL_PERCENT)

	BOT_COUNT = 20
	client.send_add_bot(BOT_COUNT)

	client.send_restart_game()

	while True:
		server.update()

		client.update()
		client.draw(screen)

		time.sleep(1.0 / 60)

def start(args, kill = None):
    config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pywps.cfg")

    processes = [
        FeatureCount(),
        SayHello(),
        Centroids(),
        UltimateQuestion(),
        Sleep(),
        Buffer(),
        Area(),
        Box(),
        Warp()
    ]

    s = Server(processes=processes, config_file=config_file)

    # TODO: need to spawn a different process for different server
    if args.waitress:
        import waitress
        from pywps import configuration

        configuration.load_configuration(config_file)
        host = configuration.get_config_value('wps', 'serveraddress').split('://')[1]
        port = int(configuration.get_config_value('wps', 'serverport'))

        waitress.serve(s.app, host=host, port=port)
    else:
        s.run()

	def test_assertPathOk(self) :
		s = Server("badpath")
		try :
			s._assertPathOk()
			self.fail("Exception expected")
		except BadServerPath, e:
			self.assertEqual(e.message, "badpath")

    def run(self):
        """
        Start HTTP daemon
        """
        self.log("Starting new API instance on %d" % self.port)
        http_handler = Handler
        SocketServer.TCPServer.allow_reuse_address = True

        try:
            http_service = ApiServer((self.host, self.port), http_handler, manager=self.manager)
        except socket.error as e:
            self.log("Failed to bind to port. Got: %s" % str(e))
            return False

        if self.ssl:
            self.manager.get_key({'hostname': self.ssl, 'algo': 'RSA', 'bits': 2048})
            key_path = self.manager.get_key_path(self.ssl)

            while True:
                res = self.manager.cert({'hostname': self.ssl, 'ip': '127.0.0.1'})
                if res['status'] != 'available':
                    time.sleep(10)
                    continue

                self.log("Certificate successfully received for %s" % self.ssl)
                break

            cert_path = self.manager.get_fullchain_path(self.ssl)
            self.log("Key: %s, Cert: %s" % (key_path, cert_path))
            http_service.socket = ssl.wrap_socket(http_service.socket, keyfile=key_path, certfile=cert_path, server_side=True)

        self.log("HTTP API server started")
        while self.is_running():
            http_service.handle_request()

class DemoMicroBridge(ServerListener):
    def __init__(self):
        self.droid = android.Android()
        self.droid.webViewShow('file:///sdcard/sl4a/scripts/microbridge/demo.html')

        # Start server
        self.server = Server()
        self.server.add_listener(self)
        self.server.start()

    def on_server_started(self, server):
        print "Server Started!"

    def on_client_connect(self, server, client):
        print "Client Connected!"

    def on_client_disconnect(self, server, client):
        print "Client Disconnected!"

    def on_receive(self, client, string):
        # print "Received " + string

        # Received data from ADC
        # Arduino uses little-endian format
        data = 0
        for d in string[::-1]:
            data = data << 8 | ord(d)
        self.droid.eventPost("ADC", str(data))

 def __init__(self, core="tarantool"):
     Server.__init__(self, core)
     self.default_bin_name = "tarantool_box"
     self.default_config_name = "tarantool.cfg"
     self.default_init_lua_name = "init.lua"
     # append additional cleanup patterns
     self.re_vardir_cleanup += ['*.snap',
                                '*.xlog',
                                '*.inprogress',
                                '*.cfg',
                                '*.sup',
                                '*.lua']
     self.process = None
     self.config = None
     self.vardir = None
     self.valgrind_log = "valgrind.log"
     self.valgrind_sup = os.path.join("share/", "%s.sup" % ('tarantool'))
     self.init_lua = None
     self.default_suppression_name = "valgrind.sup"
     self.pidfile = None
     self.port = None
     self.binary = None
     self.is_started = False
     self.mem = False
     self.start_and_exit = False
     self.gdb = False
     self.valgrind = False

	def serve_forever(self, poll_interval=0.5):
		# make sure every process knows the https parent pid
		secure_pid = os.getpid()
		plain_pid = os.fork() if self.plain_mode else None
		# when using simultaneous plain http, fork and run that part on the child.
		# os.fork() warns about ssl and multiprocessing. I think we're okay tho,
		# since only the parent does any ssl and its right on the socket???

		# plain (child) part:
		if plain_pid == 0:
			# TODO: catch signals from / poll for pid of parent?
			try:
				self.plain_server.serve_forever(poll_interval)
			finally:
				# could probably investigate the nature of our pid more closely,
				# however pidfiles are too tryhard atm
				if secure_pid == os.getppid():
					os.kill(secure_pid, signal.SIGTERM)


		# secure (parent) part:
		else:
			# might get away w/ lazy style? if more sophisticated management is desired
			# can override SocketServer.py copypastastyle
			try:
				Server.serve_forever(self, poll_interval)
			finally:
				# again, might want to think at least two seconds about our cleanup...
				# None == no fork even happened.
				if plain_pid is not None:
					os.kill(plain_pid, signal.SIGTERM)

    def setUp(self):
        temp = tempfile.NamedTemporaryFile()
        filename_temp = temp.name
        temp.close()

        Server.SOCKET_ATTR = (socket.AF_UNIX, socket.SOCK_STREAM)
        Server.SOCKET_HOST = filename_temp

        server = Server()
        worker = Worker(target=server.initSocket)
        worker.start()
        self.server = server
        self.worker = worker
        self.filename_temp = filename_temp

        # wait socket up
        while not hasattr(server, '_server_socket'):
            pass

        self.clients = []
        self._new_client()
        self._new_client()

        gid = server.create_game(self.clients[0].uid, 'JungleRumble')
        server.join_game(self.clients[1].uid, gid)

        result = self.clients[0].read() # new_opponent

def main():
    # Build the library
    subprocess.call(['npm', 'run', 'build'])
    # Copy the library to the http server path
    subprocess.call([
        'cp',
        join(BASEDIR, '..', 'dist/ether.global.js'),
        join(BASEDIR, 'public')
    ])
    # Build the sample user app under test
    # Building the app only works if dir is set properly
    os.chdir(BASEDIR)
    subprocess.call(['node', join(BASEDIR, 'rollup.js')])

    # Start the http server
    httpd = Server()
    httpd.start()

    # Run CasperJS tests
    subprocess.call([
        join(BASEDIR, '..', 'node_modules/casperjs/bin/casperjs'),
        'test', '--log-level=debug', '--verbose',
        join(BASEDIR, 'test')
    ])

    # Stop the http server
    httpd.stop()

 def test_slice_line(self):
     print "::test_slice_line starts ..."
     sv = Server()
     sv.stored_previous_partial = "cuu"
     sv.prepared_line = "p   B"
     sv.slice_line()
     self.assertEquals("cuu", sv.sm.slice_result[0])

def crawl_listing():
    from server import Server
    ss = Server()
#    pool = Pool(50)
    it = 0 
    num_cats = Category.objects().count()
    for c in Category.objects(is_leaf=True):
        it += 1
        print c.catname, it, 'of', num_cats
        if c.spout_time and  c.spout_time > datetime.utcnow()-timedelta(hours=8):
            print '...skipped'
            continue
        if c.num:
            num_page = (c.num - 1) // ITEM_PER_PAGE + 1
            for page in xrange(1, num_page+1):
                page_item_NO = (page-1)*ITEM_PER_PAGE
                url = c.url( page_item_NO )
                if page == num_page:
#                    pool.spawn(ss.crawl_listing, url, c.catstr, page, c.num % ITEM_PER_PAGE)
                    ss.crawl_listing( url, c.catstr(), page, c.num % ITEM_PER_PAGE)
                else:
#                    pool.spawn(ss.crawl_listing, url, c.catstr, page)
                    ss.crawl_listing( url, c.catstr(), page)
                progress(str(page)+' ')
            print
        c.spout_time = datetime.utcnow()
        c.save()

def main():
    import argparse

    parser = argparse.ArgumentParser()
    parser.add_argument('-w', '--waitress', action='store_true')
    args = parser.parse_args()

    config_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pywps.cfg")

    processes = [
        FeatureCount(),
        SayHello(),
        Centroids(),
        UltimateQuestion(),
        Sleep(),
        Buffer(),
        Area(),
        Viewshed()
    ]

    s = Server(processes=processes, config_file=config_file)

    # TODO: need to spawn a different process for different server
    if args.waitress:
        import waitress
        from pywps import configuration

        configuration.load_configuration(config_file)
        host = configuration.get_config_value('wps', 'serveraddress').split('://')[1]
        port = int(configuration.get_config_value('wps', 'serverport'))

        waitress.serve(s.app, host=host, port=port)
    else:
        s.run()

class Master():
  def __init__(self):
    self.client = None
    self.server = None

  def call(self, host, port):
    if self.client==None:
      self.client = Client(self)
      self.client.call(host, port)
  
  def callOn(self, addr):
    if self.client == None:
      self.client = Client(self)
      thread.start_new_thread(
        self.client.call, addr)

  def serve(self):
    if self.server==None:
      self.server = Server(self)
      self.server.listen()

  def serveOn(self, socket):
    if self.server==None:
      self.server = Server(self)
      thread.start_new_thread(
          self.server.listenTo, (socket,))

    def do_upload(self, path, gfile, server):
        """
        Upload a single file to the gauntlet cache
        """
        repopath = os.path.abspath(path)

        if not repopath.startswith(self.repo.working_tree_dir):
            print("{}: File must be inside the "
                    "working tree folder".format(path), file=sys.stderr)
            return 1

        repopath = os.path.relpath(repopath, self.repo.working_tree_dir)

        # FIXME: Make sure repopath is in self.repo.untracked_files
        # once GitPython is updated and that property starts working again.

        if not os.path.exists(path):
            print("'{}' does not exist".format(repopath), file=sys.stderr)
            return 1

        server = Server(server)

        # The server is in flask, and apparently WSGI can't handle chunked
        # requests. There's code to implement a progress bar below, but it's
        # disabled since we have to chunk the request to do it.
        #
        # See https://github.com/mitsuhiko/flask/issues/367
        #
        #if os.isatty(2): #stderr
        #    progress = self.progress("Uploading", repopath,
        #            os.path.getsize(self.args.path))
        #else:
        #    progress = None

        with open(path, 'r') as f:
            #def f_iter():
            #    data = 'a'
            #    count = 0
            #    while len(data):
            #        data = f.read(4096)
            #        yield data
            #        count += len(data)
            #        progress.update(count)

            #if progress:
            #    progress.start()
            #    sha = server.post(f_iter())
            #    progress.finish()
            #else:
            #    sha = server.post(f)
            sha = server.post(f)

        gfile['files'][repopath] = str(sha)

        with open(os.path.join(self.repo.working_tree_dir, '.gitignore'),
            'a') as ignore:
            print(repopath, file=ignore)

        return 0

def foreGround(clt, args):
    # --
    if "session_object" not in args:
        return
    session = args["session_object"]
    # --
    # Wait until gui is arrived
    # tmax = nbtot * dt
    # --
    gui_detected = False
    dt = 0.1
    nbtot = 100
    nb = 0
    while 1:
        try:
            status = session.GetStatSession()
            gui_detected = status.activeGUI
        except:
            pass
        if gui_detected:
            break
        from time import sleep
        sleep(dt)
        nb += 1
        if nb == nbtot:
            break
        pass
    # --
    if not gui_detected:
        return
    # --
    from salome_utils import getPortNumber
    port = getPortNumber()
    # --
    server = Server({})
    if sys.platform == "win32":
      server.CMD = [os.getenv("PYTHONBIN"), "-m", "killSalomeWithPort", "--spy", "%s"%(os.getpid()), "%s"%(port)]
    else:
      server.CMD = ["killSalomeWithPort.py", "--spy", "%s"%(os.getpid()), "%s"%(port)]
    server.run()
    # os.system("killSalomeWithPort.py --spy %s %s &"%(os.getpid(), port))
    # --
    dt = 1.0
    try:
        while 1:
            try:
                status = session.GetStatSession()
                assert status.activeGUI
            except:
                break
            from time import sleep
            sleep(dt)
            pass
        pass
    except KeyboardInterrupt:
        from killSalomeWithPort import killMyPort
        killMyPort(port)
        pass
    return

 def initArgs(self):
     Server.initArgs(self)
     if sys.platform == "win32":
       env_ld_library_path = ['env', 'LD_LIBRARY_PATH=' + os.getenv("PATH")]
     else:
       env_ld_library_path = ['env', 'LD_LIBRARY_PATH=' + os.getenv("LD_LIBRARY_PATH")]
     self.CMD = ['xterm', '-e']+ env_ld_library_path + ['python']
     self.initNSArgs()