def __init__(self,sock,parent,reconnect=None):
self.name = None
self.flood = parent.server.flood
self.parent = parent
self.server = parent.server
self.dbg = self.server.dbg
self.nfo = self.server.nfo
self.err = self.server.err
async_chat.__init__(self,sock)
self.set_terminator(b'\n')
self.relay = True
self.reconnect = reconnect
self.ibuff = []
self._actions = {
'privmsg':self.on_privmsg,
'notice':self.on_notice,
'join':self.on_join,
'part':self.on_part,
'topic':self.on_topic,
'kick':self.on_kick,
'quit':self.on_quit,
'server':self.on_server
}
self.children = []
self.send_initial_servers()
def __init__(self,sock):
async_chat.__init__(self,sock)
self.data=[]
self.set_terminator("\n")
t=threading.Thread(target=self.sendMsg)
t.setDaemon(True)
t.start()
def __init__(self, host, port, line_read):
async_chat.__init__(self)
self.line_read = line_read
self.received_data = []
self.set_terminator(b"\n")
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.connect((host, port))
def __init__(self, server, sock):
''' Individual client's link to the server. '''
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
self.name = None
def __init__(self, sock, worker_number, result_array, timing):
async_chat.__init__(self, sock)
self.in_buffer = []
self.set_terminator("--END--")
self.number = worker_number
self.results = result_array
self.timing = timing;
def __init__(self, sock, svr):
async_chat.__init__(self, sock)
self.server = svr
self.set_terminator("\r\n") # terminator of conn stream process
self.data = []
# welcome
self.push('Welcome to %s\r\n' % self.server.name)
def __init__(self, host, port):
''' Communicates between the GUI and server. '''
async_chat.__init__(self)
self.data = []
self.ID = -1
self.ch = ClientHelper(self)
while True:
if host == None:
host = raw_input("Enter the IP of the server (leave blank for localhost) >")
if len(host.strip()) == 0:
host = "localhost"
try:
print "connecting to...",host
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.connect((host,port))
self.set_terminator("\n")
self.register()
try: asyncore.loop()
except KeyboardInterrupt: print
break
except Exception:
print "Cannot connect, ", Exception
host = None
def __init__(self,server,sock):
async_chat.__init__(self,sock)
self.server=server
self.set_terminator("\n")
self.data=[]
self.name=None
self.enter(LoginRoom(server,""))
def __init__(self, server, socket):
async_chat.__init__(self, sock)
self.server=server
self.set_terminator("\r\n")
self.data=[]
self.push('Welcome to %s\r\n' %self.server.name)
def __init__(self, conn, addr, server):
async_chat.__init__(self, conn)
self.client_address = addr
self.connection = conn
self.server = server
self.set_terminator ('\n')
self.found_terminator = self.handle_request_line
def __init__(self, fp, address, port=0, log_fh=None, counter=0, error_profile=None):
"""connect to server and init object.
fp: file path base name to use for intermediate files
address: server address
port: server port to connect to
log_fh: if not None log some messages to log_fh
counter: counts each round of denoising
"""
async_chat.__init__(self)
self.log_fh = log_fh
self.counter = counter
self.fp = fp
self.error_profile = error_profile
self.in_buffer = []
self.create_socket(AF_INET, SOCK_STREAM)
if self.log_fh:
self.log_fh.write("Client %s trying to connect to %s:%s\n" % (fp, address, port))
#loop until connection to server established
while True:
try:
self.connect((address, port))
if self.log_fh:
self.log_fh.write("client connected to %s\n" % str(self.getpeername()))
break
except error, msg:
if self.log_fh:
self.log_fh.write("Server not ready: %s\n" % msg)
sleep(1)
def __init__(self, server, socket):
async_chat.__init__(self, socket);
self.server = server;
self.rawInStr = "";
self.rawOutStr = "";
self.request = {};
self.set_terminator("\r\n\r\n");
self.found_terminator = self.handle_http_header;
def __init__(self,sock,server):
async_chat.__init__(self,sock)
self.set_terminator(SEP)
self.data = []
# save server of this session
self.server = server
# send message to client of this session
self.push('Welcome to {0}\n'.format(self.server.name))
def __init__(self,server,sock):
async_chat.__init__(self,sock)
self.server=server
self.set_terminator("\r\n")
self.data=[]
self.name='Anonymous'
self.room=None
self.enter(LoginRoom(server))
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
self.name = None
# All sessions begin in a separate LoginRoom:
self.enter(LoginRoom(server))
def __init__(self,server,sock):
async_chat.__init__(self,sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
self.name = None
#所有的会话都开始于单独的LoginRoom中
self.enter(LoginRoom(server))
def __init__(self, server, sock):
# Standard setup tasks:
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
# Greet the user:
self.push("Welcome to %s\r\n" % self.server.name)
def __init__(self, server, sock):
async_chat.__init__(self, sock) #标准设置任务
self.server = server
self.set_terminator("\r\n") #用于将行终止符设定为\r\n，它也是网络协议中通用的终止符
self.data = []
#问候用户:
# Pushes data on to the channel’s fifo to ensure its transmission. This is all you need to do to have the channel write the data out to the network, although it is possible to use your own producers in more complex schemes to implement encryption and chunking, for example.
self.push('welcome to %s\r\n' % self.server.name)
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
self.user = None
self.loginroom = LoginRoom(server)
self.enter(self.loginroom)
def __init__(self, server, sock):
async_chat.__init__(self,sock)
self.server = server
self.set_terminator("\r\n") #用于将行终止符设定为\r\n，它也是网络协议中通用的终止符
self.data = []
self.name = None
#所有的会话都开始于单独的LoginRoom中：
self.enter(LoginRoom(server))
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
self.text_received = ""
self.nick = ""
self.language = "en"
def __init__(self, server, sock):
# 标准设置任务：
async_chat.__init__(self, sock)
self.server = server
self.set_terminator('\r\n')
self.data = []
# 问候用户
self.push('Welcome to %s\r\n' % self.server.name)
def __init__(self, server, sock, addr):
async_chat.__init__(self, sock)
self.server = server
self.ipaddr = addr
self.set_terminator("\n")
self.name = None
self.data = []
self.sock = sock
self.enter(FirstLogin(server, addr[0])) #Call the login procedure before anything.
def __init__(self,sock,server): async_chat.__init__(self,sock) self.server = server self.set_terminator(RN) self.data = [] self.name = None self.room = None # record which kind of room # all sessions start with LoginRoom self.enter(LoginRoom(self.server))
def __init__(self, chatserver, sock):
async_chat.__init__(self, sock)
self.set_terminator('\r\n')
self.__clientdata = []
self.__logic = None
self.__server = chatserver
self.username = "******"
def __init__(self,server,sock):
async_chat.__init__(self,sock)
self.server=server
self.use_encoding=1
self.encoding='utf-8'
self.set_terminator("\r\n")
self.data=[]
self.push(('Welcome to %s\r\n' % self.server.name).encode())
def __init__(self, path=None, disableLog=False):
"""
Initiates the parent and some necessary variables.
Then reads the configuration, finds all the plugins and their
hooks and instantiates them.
:param path: path to the `config.json` and plugins folder.
"""
# unless we get disableLog we log level info to stdout until reading
# the config file
if not disableLog:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s'))
self.logger.addHandler(handler)
self.logger.setLevel("INFO")
self.logger.info("Initiation the bot..")
# saving the path
if path:
self.path = path
else:
self.path = os.getcwd()
self.logger.info("Using '%s' as bot path." % self.path)
# system crap
async_chat.__init__(self)
self.set_terminator('\r\n')
self.buffer = ''
# access self.paths to init Alebot.Paths
self.paths
# load the default config
self.config = {
'nick': 'alebot',
'ident': 'alebot',
'realname':
'alebot python irc bot. https://github.com/alexex/alebot',
'server': 'irc.freenode.net',
'port': 6667,
'logToStdout': True,
'logLevel': 'INFO',
'logFormatter': '%(asctime)s - %(levelname)s - %(message)s',
'logFile': False
}
# load an eventual configuration
self.load_config()
# load plugins
self.load_plugins()
# activate plugin hooks
self.activate_hooks()
def __init__(self): async_chat.__init__(self) self.create_socket(socket.AF_INET,socket.SOCK_STREAM) self.address = '' self.pager = '' self.message = '' self.chan = SNPPChannel() self.collect_incoming_data = self.chan.collect async_chat.set_terminator(self,'\r\n')
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.set_terminator('\n')
self.data = []
self.server = server
self.nickname = ""
self.nameFlag = False
self.push("Enter you nickname: \n")
def __init__(self,sock,parent,name='?'):
async_chat.__init__(self,sock)
self.parent = parent
self.server = parent.server
self.set_terminator(self.parent.delim)
self.ibuffer = ''
self.state = 0
self.name = name
self.dbg = lambda m : self.parent.dbg('link-%s %s'%(self.name,m))
self.handle_error = self.server.handle_error
self.init()
def __init__(self, server, port, nickname, channels, realname=False, username=False, hostname=False, hammer_interval=10, alarm_timeout=300, kill_timeout=360, loglevel=logging.ERROR):
asychat.__init__(self)
#logger magic
self.log = logging.getLogger('asybot_' + nickname)
#hdlr = logging.handlers.SysLogHandler(facility=logging.handlers.SysLogHandler.LOG_DAEMON)
#formatter = logging.Formatter( '%(filename)s: %(levelname)s: %(message)s')
#hdlr.setFormatter(formatter)
#self.log.addHandler(hdlr)
logging.basicConfig(level = loglevel)
self.nickname = nickname
if realname:
self.realname = realname
else:
self.realname = nickname
if username:
self.username = username
else:
self.username = nickname
if hostname:
self.hostname = hostname
else:
self.hostname = nickname
self.retry = True
self.server = server
self.port = port
self.channels = channels
self.data = ''
self.myterminator = '\r\n'
self.set_terminator(self.myterminator.encode())
self.create_socket(AF_INET, SOCK_STREAM)
self.connect((self.server, self.port))
self.wrapper = TextWrapper(subsequent_indent=" ",width=400)
self.log.info('=> irc://%s@%s:%s/%s' % (self.nickname, self.server, self.port, self.channels))
# When we don't receive data for alarm_timeout seconds then issue a
# PING every hammer_interval seconds until kill_timeout seconds have
# passed without a message. Any incoming message will reset alarm.
self.alarm_timeout = alarm_timeout
self.hammer_interval = hammer_interval
self.kill_timeout = kill_timeout
try:
signal(SIGALRM, lambda signum, frame: self.alarm_handler())
except Exception as e:
print('asybot: ' + str(e))
self.reset_alarm()
def __init__(self, server, sock):
"""Init method.
Args:
server (ChatServer): The server to connect to.
sock (): The socket given to the user.
"""
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
self.name = None
#all sessions begin in a separate login room.
self.enter(LoginRoom(server))
def __init__(self,sock,parent):
chat.__init__(self,sock)
self.handle_error = parent.handle_error
self.parent = parent
self.set_terminator(b'\n')
self._ibuffer = []
self._inq = []
self.client = None
self.version = None
self.status = 'offline'
self._client = parent._client
self.dbg = parent.dbg
self._ready = True
self.get_last_msg = self._pop_chat
def __init__(self, server, port, nickname, targets, bottype, probability,
**kwargs):
asychat.__init__(self)
if bottype == "cleverbot":
self.botfactory = factory.create(ChatterBotType.CLEVERBOT)
elif bottype == "jabberwacky":
self.botfactory = factory.create(ChatterBotType.JABBERWACKY)
elif bottype == "pandorabots":
self.botfactory = factory.create(ChatterBotType.PANDORABOTS,
"c7068fbf3e344abf")
elif bottype == "twssbot":
self.botfactory = factory.create(ChatterBotType.TWSSBOT)
else:
log.error("do not know bottype %s" % bottype)
exit(1)
self.bot = self.botfactory.create_session()
self.probability = probability
self.server = server
self.port = port
self.nickname = nickname
self.targets = targets
self.username = kwargs['username'] if 'username' in kwargs else nickname
self.hostname = kwargs['hostname'] if 'hostname' in kwargs else nickname
self.ircname = kwargs['ircname'] if 'ircname' in kwargs else nickname
self.realname = kwargs['realname'] if 'realname' in kwargs else nickname
log.info("This is " + BOT_VERSION)
log.info("Probability : " + str(probability))
log.info("nick : " + str(nick))
log.info("Bottype: " + str(bottype))
self.data = ''
self.set_terminator('\r\n')
self.create_socket(AF_INET, SOCK_STREAM)
self.connect((self.server, self.port))
self.wrapper = TextWrapper(subsequent_indent=" ", width=400)
# When we don't receive data for alarm_timeout seconds then issue a
# PING every hammer_interval seconds until kill_timeout seconds have
# passed without a message. Any incoming message will reset alarm.
self.alarm_timeout = 300
self.hammer_interval = 10
self.kill_timeout = 360
signal(SIGALRM, lambda signum, frame: self.alarm_handler())
self.reset_alarm()
def __init__(self, server, conn, addr):
self.channel_number = Channel.channel_counter.increment()
self.addr = addr
self.server = server
# Leaving out connection and map because we set them below.
AsyncChat.__init__(self)
self._map = REDUSA_SOCKET_MAP
self._in_buffer = ''
self._current_request = None
self._null_request = _NullRequest()
self._request_queue = [self._null_request]
self._keep_alive = 1
self._last_use = int(time.time())
self.check_maintenance()
self.set_socket(conn, self._map)
self.socket.setblocking(0)
self._is_connected = True
self.connected = True
self._setup_counters()
self.reset()
def __init__(self,
fp,
address,
port=0,
log_fh=None,
counter=0,
error_profile=None):
"""connect to server and init object.
fp: file path base name to use for intermediate files
address: server address
port: server port to connect to
log_fh: if not None log some messages to log_fh
counter: counts each round of denoising
"""
async_chat.__init__(self)
self.log_fh = log_fh
self.counter = counter
self.fp = fp
self.error_profile = error_profile
self.in_buffer = []
self.create_socket(AF_INET, SOCK_STREAM)
if self.log_fh:
self.log_fh.write("Client %s trying to connect to %s:%s\n" %
(fp, address, port))
# loop until connection to server established
while True:
try:
self.connect((address, port))
if self.log_fh:
self.log_fh.write("client connected to %s\n" %
str(self.getpeername()))
break
except error as msg:
if self.log_fh:
self.log_fh.write("Server not ready: %s\n" % msg)
sleep(1)
self.set_terminator("--END--")
def __init__(self, map, debug=0):
AsyncChat.__init__(self)
self.channel_number = self.channel_counter.increment()
self.monitor = self._map = map
self.debug = debug
self._fileno = None
self._keep_alive = 1
self._using_ssl = False
self._ssl_context = None
self._pending_requests = []
self._sending_requests = []
self._current_response = None
self._is_connected = False
self._connection_initiated = False
self._accepting_requests = True
self._is_closed = False
self._header_buffer = StringIO()
self._constate_lock = Lock()
self.reset_terminator()
self._setup_counters()
self._born_on = self._last_use = time.time()
def __init__(self,
chess4irc,
host,
port,
nickname,
username,
channels=None):
async_chat.__init__(self)
self.shutdown = 0
self.chess4irc = chess4irc
self.host = host
self.port = port
self.nickname = nickname
self.username = username
self.channels = [] if (channels is None) else channels
self.received_data = ''
self.print_debug('__init__: connecting to %(host)s:%(port)d' % {
'host': host,
'port': port
})
self.create_socket(AF_INET, SOCK_STREAM)
self.connect((host, port))
def __init__(self, server, port, nickname, targets, **kwargs):
asychat.__init__(self)
self.server = server
self.port = port
self.nickname = nickname
self.targets = targets
self.username = kwargs['username'] if 'username' in kwargs else nickname
self.hostname = kwargs['hostname'] if 'hostname' in kwargs else nickname
self.ircname = kwargs['ircname'] if 'ircname' in kwargs else nickname
self.realname = kwargs['realname'] if 'realname' in kwargs else nickname
self.data = ''
self.set_terminator('\r\n')
self.create_socket(AF_INET, SOCK_STREAM)
self.connect((self.server, self.port))
self.wrapper = TextWrapper(subsequent_indent=" ",width=400)
# When we don't receive data for alarm_timeout seconds then issue a
# PING every hammer_interval seconds until kill_timeout seconds have
# passed without a message. Any incoming message will reset alarm.
self.alarm_timeout = 300
self.hammer_interval = 10
self.kill_timeout = 360
signal(SIGALRM, lambda signum, frame: self.alarm_handler())
self.reset_alarm()
def __init__(self, server, sock):
#标准设置任务。
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\r\n")
self.data = []
def __init__(self, sock):
async_chat.__init__(self, sock)
self.set_terminator('\r\n'.encode()) #设置结束符为\r\n,(网络协议常用行结束符)
self.data = [] #将已读取的数据存储在字符串列表
self.push('欢迎进入聊天室！'.encode())
def __init__(self, sock):
async_chat.__init__(self, sock)
self.set_terminator('\r\n'.encode()) # 设置数据的终止符号
self.data = [] # 创建数据列表
self.push('欢迎进入聊天室！'.encode('GBK')) # 向单个客户端发送欢迎信息
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator('\n')
self.data = []
def __init__(self, addr):
async_chat.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.bind(addr)
self.listen(5)
def __init__(self, server, sock, RemoteIP, logger):
async_chat.__init__(self, sock)
self.server = server
self.logger = logger
self.SerialID = None
self.RemoteIP = RemoteIP
self.set_terminator(None)
# ----------------- /
# Related To Redis
# ----------------- /
self.redataIP = "10.2.10.19"
self.redataPort = 6379
self.redataDB = 0
# ----------------- /
# Packet Type Command Description
# ----------------- /
#####################
# Server To Device Commands
#####################
#@Restart Reader Cmd To Device
self.cmd_svr_restart_reader = "5501" # 0x5501
#@Sync Server Time To Device
self.cmd_svr_sync_time = "5502" # 0x5502
#@Set Network Parameters To Device
self.cmd_svr_set_net_para = "5503" #0x5503
#@Send Command To Device For Get Config Parameter
self.cmd_svr_get_conf_para = "5504" #0x5504
# #@Set Heartbeat Packet Interval To Device
# self.cmd_svr_set_heartbeat_interval = "5504" #0x5504
# #@Set Antenna Power To Device
# self.cmd_svr_antenna_power = "5505" #0x5505
# #@Set Reader SerialID To Device
# self.cmd_svr_set_reader_serialid = "5506" #0x5506
######################
# Device To Server Commands
######################
#@Request Sync Time From Device
self.cmd_dev_sync_time = "aa01" # 0xaa01
#@Attendance Data Or Heartbeat Packet From Device
self.cmd_dev_data_packet = "aa02" # 0xaa02
#@Attendance Device Confg Parameter From Device
self.cmd_dev_conf_para = "aa03" # 0xaa03
#######################
# Admin Platform Api to Server Commands
#######################
#@Restart Reader To Specified Device
self.cmd_admin_restart_reader = "cc01" # 0xcc01
#@Sync Server Time To Specified Device
self.cmd_admin_sync_time = "cc02" # 0xcc02
#@Set Network Parameters To Specified Device
self.cmd_admin_set_net_para = "cc03" # 0xcc03
#@Send Command To Device For Get Config Parameter
self.cmd_admin_get_conf_para = "cc04" # 0xcc04
def __init__(self,sock):
async_chat.__init__(self,sock)
self.set_terminator("\r\n") #以换行符作为结束符
self.data = []
print('ChatSession -- __init__')
def __init__(self,server, sock, user="******"):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator("\n")
self.data = []
self.user = user
def __init__(self, conn, handler):
async_chat.__init__(self, conn=conn)
self.ibuffer = []
self.handler = handler
self.set_terminator('\n')
def __inin__(self, sock):
async_chat.__init__(self, sock)
self.set_terminator("\r\n") # 设置行结束符为网络协议中常用结束符
self.data = []
def __init__(self, sock):
async_chat.__init__(self, sock)
self.set_terminator(b'\r\n')
self.data = []
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator(b'\r\n')
self.data = []
self.push(b"Welcome to " + str.encode(self.server.name))
def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.socket = sock
self.server = server
self.set_terminator("\n")
self.data = []
def __init__(self,socket):
async_chat.__init__(self,socket)
self.set_terminator = "\r\n"
self.data = []
def __init__(self, sock):
async_chat.__init__(self, sock)
self.async_chat.set_terminator("\r\n")
self.data = []
def __init__(self, monitor):
self.number = self.counter.increment()
self.debug = False
self.monitor = monitor
AsyncChannel.__init__(self)
AsyncDispatcher.__init__(self, map=monitor)
def __init__(self,server,sock):
async_chat.__init__(self,sock)
self.server=server
self.set_terminator('\r\n')
self.date=[]
self.push('Welcome to %s\r\n') \n' % self.server.name)
def __init__(self, sock, line_read):
async_chat.__init__(self, sock=sock)
self.line_read = line_read
self.received_data = []
self.set_terminator("\n")
