def prepSimProfile(self):
     """
         Prepare data and create User Sessions (to be simulated). 
         each of them will wait for the start signal.
     """
     # @todo: implement a mechanism to load and use other types of RAS (from ras_type.py)
     self.__ras_obj = MikrotikRas(self.__sim_profile.nas_id,
                                  self.__sim_profile.nas_ip,
                                  self.__sim_profile.radius_secret, 
                                  self.__sim_profile.aaa_server_ip)
     
     # @todo: we better save and keep track of the used IP
     ips = []
     for ip in IPy.IP( self.__sim_profile.user_ips ):
         if str(ip).endswith("0") or "255" in str(ip):
             continue
         ips.append( str(ip) )
     
     for i in xrange( self.__sim_profile.total_sessions ):
         session_type = random.choice( self.__sim_profile.session_types )
         self.__start_sessions[ session_type ] = 1 + self.__start_sessions.get(session_type, 0)
         username, password = self.__genUserPass(i)
         sess = Session(session_type, self.__ready_event,
                  username, password,
                  ips.pop(0), self.__ras_obj)
         
         sess.start()
         self.__sessions.append(sess)

  def get_responses(self, id_=1):
    session = Session()
    bbs = session.query(BBS).filter(BBS.id == id_).one()

    responses = [ res.toDict() for res in bbs.responses]
    responses.reverse()
    return responses

class AppDelegate(NSObject):
  def applicationDidFinishLaunching_(self, app):
    self.session = None
    self.init_status_bar()
    self.init_menu()

  def init_status_bar(self):
    self.status_bar = NSStatusBar.systemStatusBar()
    self.status_item = self.status_bar.statusItemWithLength_(NSVariableStatusItemLength)
    self.status_item.setHighlightMode_(1)

    icon = NSImage.alloc().initWithContentsOfFile_('icon.png')
    self.status_item.setImage_(icon)

  def init_menu(self):
    self.menu = NSMenu.alloc().init()
    self.menu_item_start = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_('Start', 'start:', '')
    self.menu.addItem_(self.menu_item_start)
    menu_item_quit = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_('Quit', 'terminate:', '')
    self.menu.addItem_(menu_item_quit)
    self.status_item.setMenu_(self.menu)

  def start_(self, notification):
    if self.session != None:
      self.session.stop()
    self.session = Session()
    self.session.start()

 def post(self):
     username = self.get_argument("username", "")
     password = self.get_argument("password", "")
     error_messages = list()
     if username == "" or password == "":
         error_messages.append("参数不能为空")
         self.render("login.html", error_messages=error_messages, username="")
         return
     user = self.db.get("SELECT * FROM accounts WHERE username = %s", username)
     if user is None:
         error_messages.append("用户名密码错误")
         self.render("login.html", error_messages=error_messages, username=username)
         return
     if user["status"] == 0:
         error_messages.append("帐户没有开通")
         self.render("login.html", error_messages=error_messages, username=username)
         return
     password_generator = UserPassword()
     password_hash = password_generator.generate_hash(password, user["password_salt"])
     if password_hash != user["password_hash"]:
         error_messages.append("用户名密码错误")
         self.render("login.html", error_messages=error_messages, username=username)
         return
     session = Session(self.settings["session_secretSid"], self.settings["session_secretEid"], self.settings["session_expired"])
     if session.encode(user["id"]) is False:
         error_messages.append("用户数据错误")
         self.render("login.html", error_messages=error_messages, username=username)
         return
     sid = session.getSid()
     eid = session.getEid()
     self.set_secure_cookie("sid", sid, None)
     self.set_secure_cookie("eid", eid, None)
     self.redirect(self.get_argument("next", "/"))

def command_start(bot, update):
    chat_id = update.message.chat_id
    if chat_id not in SESSIONS.keys():
        messenger = Messenger(bot, logger)
        SESSIONS[chat_id] = Session(chat_id, config_instance, logger)
        SESSIONS[chat_id].set_messenger(messenger)
        SESSIONS[chat_id].quiz = Quiz(SESSIONS[chat_id])

    def get(self):
        if 'pairing' in self.request.arguments:
            key = self.get_argument('pairing')
            # validate pairing key

            if 'type' in self.request.arguments:
                if 'session' in self.request.arguments:
                    session = Session.get(self.get_argument('session'))
                    if session:
                        if self.get_argument('type') == 'update':
                            self.writeout( session.get_update() )
                        elif self.get_argument('type') == 'function':
                            queries = self.get_argument('queries')
                            qargs = json.loads(queries)
                            args = [urllib.unquote(arg) for arg in qargs]
                            decoded = [decode_func_args(a) for a in args]
                            for fnargs in decoded:
                                self.writeout( session.handle_function(fnargs) )
                                return
                        else:
                            self.writeout( { 'no':'huh' } )
                        # validate session
                        #self.writeout( [ {'add': {'btapp':{'torrent':{'aotheu':{'hello':23}}}} } ] )
                    else:
                        self.set_status(404)
                else:
                    #logging.info('no session id in args -- %s, %s' % (self.request.uri, self.request.arguments))
                    session = Session.create(Client.instances[0])
                    self.writeout( {'session':session.id} )
            else:
                self.writeout( { 'hey':'whatup' } )
        else:
            self.set_status(403)

def killProcess(agent, user, password, pid):
    s = Session(agent, service="ProcessStop")
    s.authorize(user, password)

    response = s.doRequest(attributes={"PID" : str(pid)})

    return int(ElementTree.fromstring(response).get("ExitCode"))

 def get(self):
     username = self.request.get("user")
     password = self.request.get("password")
     
     self.response.headers['Content-Type'] = 'application/json; charset=utf-8'
     
     if not username or not password:
         # some fields were missing in the request
         self.response.write(json_error('invalid', ''))
     else:
         # check if username exists in db
         query_user = User.query(User.username == username).fetch()
         if query_user:
             # check if password is correct
             query = User.query(ndb.AND(User.username == username, User.pswd == password)).fetch()
             if query:
                 # generate 64 char session cookie and send it back
                 cookie = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(64))
                 session = Session(cookie = cookie, user = username)
                 session.put()
                 self.response.write(login_response('ok', cookie))   
             else: 
                 # password was incorrect
                 self.response.write(json_error('failure', 'password'))
         else:
             # user didn't exist
             self.response.write(json_error('failure', 'user'))

 def on_finish(self):
     try:
         self.session.commit()            
     except Exception as e:
         self.session.rollback()
         import traceback
         logging.critical('Transaction needed to be rolled back because of: \n %s' % traceback.format_exc() )
     Session.remove()

 def __call__(self, environ, start_response):
     sc = SimpleCookie()
     if 'HTTP_COOKIE' in environ:
         sc.load(environ.get('HTTP_COOKIE'))
     ses = Session(ExpressSession(sc))
     ses.read()
     environ['express.session'] = ses
     return self.app(environ, start_response)

 def login(self, password):
     if self.password == password:
         current_session = Session(player_id=self.player_id)
         current_session.start_session()
         self.sessions.append(current_session)
         print("Player {} has logged in".format(self.name))
     else:
         print("Password error. Try again.")

    def query(self, query_type, msg_body=None):
        session = Session(self.peer.connect_str, service="Manager")
        session.authorize(self.peer.domain.user, self.peer.domain.password)
        pwd_response = session.doRequest(attributes={"Type": "GetDatabaseCredentials", "Database": self.database.name})

        pwd_xml = ElementTree.fromstring(pwd_response)
        pwd = pwd_xml.find("Password").text.strip()

        return queryEngine(self.address, self.port, query_type, pwd, msg_body)

    def __init__(self, host, port, service='SQL2'):
        """Constructor for the EncodedSession class."""
        Session.__init__(self, host, port=port, service=service)
        self.doConnect()

        self.__output = None
        self.__input = None
        self.__inpos = 0
        self.closed = False

    def execute(self, session: Session, args: Dict[str, Any]) -> ExitCode:
        data_to_remove = get_data_to_remove(session)

        data = args['data']
        args['data'] = deque(filterfalse(lambda x: x == data_to_remove, data))

        session.get_io().output('Removed {} data points'.format(len(data) - len(args['data'])))

        return ExitCode.SUCCESS

def get_data_points_per_line(session: Session) -> int:
    while True:
        data_points_per_line = get_integer_from_user(session, 'How many data points per line should be outputted: ')
        if data_points_per_line <= 0:
            session.get_io().output('Your input must be greater than zero, instead got {}'.format(str(data_points_per_line)))
            time.sleep(1)
            session.clear()
            continue
        return data_points_per_line

def retrieve_data_point_count(session: Session) -> int:
    while True:
        data_point_count = get_integer_from_user(session, 'How many data points do you want to create: ')
        if data_point_count <= 0:
            session.get_io().output('Your input must be greater than zero, instead got {}'.format(str(data_point_count)))
            time.sleep(1)
            session.clear()
            continue
        return data_point_count

    def query(self, type, msgBody=None):
        s = Session(self.getPeer().getConnectStr(), service="Manager")
        s.authorize(self.getPeer().getDomain().getUser(), self.getPeer().getDomain().getPassword())
        pwdResponse = s.doRequest(attributes={"Type": "GetDatabaseCredentials", "Database": self.getDbName()})

        pwdXml = ElementTree.fromstring(pwdResponse)
        pwd = pwdXml.find("Password").text.strip()

        return queryEngine(self.getAddress(), self.getPort(), type, pwd, msgBody)

class SocketHandler(tornado.websocket.WebSocketHandler):
    def open(self):
        logging.info("Connected: websocket")
        self.device = 'web'
        self.session = Session(self, world)
        self.session.start()

    def on_message(self, message):
        dispatch(self.session, message.strip())

def main():
    from pprint import pprint
    from sys import argv
    s = Session()
    s.login(argv[1], argv[2])

    f = Forum(s)
    pprint(f.get_hot())
    pprint(f.get_thread(argv[3]))

    def execute(self, session: Session, args: Dict[str, Any]) -> ExitCode:
        data_to_remove = get_data_to_remove(session)

        try:
            args['data'].remove(data_to_remove)
            session.get_io().output('Removed the first instance of data point "{}"'.format(data_to_remove))
        except ValueError:
            session.get_io().error('Data point "{}" is not present in the data store!'.format(data_to_remove))

        return ExitCode.SUCCESS