Пример #1
0
def upload_monitoring(self, connection, upload):
    sz = 0
    log("Monitoring started").write()
    start = time.time()
    while connection.connected:
        if self.bytesSent != sz:
            end = time.time()
            percentage = int(self.position + self.bytesSent) / int(self.size) * 100
            completed = int(self.position + self.bytesSent)
            elapsed = end-start
            speed = int((self.bytesSent-sz)/elapsed)
            if speed != 0:
                tm = (int(self.size)-int(self.bytesSent)-self.position) / speed
            else:
                tm = 99999
            eta = utcnow() + datetime.timedelta(seconds=tm)

            speed = int(speed/1024)
            upload.status, upload.progress, upload.completed, upload.eta, upload.timeleft = 'Uploading...', percentage, completed, eta, tm
            #workaround for occasionnal empty packages
            if speed:
                upload.speed = speed
            upload.save()

            sz = self.bytesSent
            start = time.time()
            if percentage >=100:
                self.reactor.disconnect_all()
                return ""
        time.sleep(1)
    log("Monitoring stoped").write()
Пример #2
0
 def on_welcome(self, connection, event):
     c = self.connection
     c.whois(event.target)
     PORT = None
     t=threading.Timer(0, self.signal_listener, [connection, event])
     t.daemon=True
     t.start()        
     with open(os.path.join(settings.BASE_DIR, "config.ini"), "r") as cfg:
         content = cfg.readlines()
         PORT = content[2][1+content[2].index("="):content[2].index("#")].strip(" ")
         cfg.close()
     if PORT:
         #manual port forwarding used
         PORT = int(PORT)
         self.dcc = self.dcc_listen(dcctype="raw", port=PORT)
     else:
         self.dcc = self.dcc_listen(dcctype="raw")
         try:
             self.prepupnp()
         except Exception as e:
             log("Couldn't create port mapping. Is upnp supported and activated ?").write()
             c.quit()
             return
     #we need to wait to get the externalip address, therefore spawn a deamon thread
     s=threading.Timer(0, self.dccsend, [connection])
     s.daemon=True
     s.start()
Пример #3
0
def monitoring(self, connection, bot, position=0):
    sz = 0
    log("Monitoring started").write()
    while connection.connected:
        percentage = int(position + self.dict[bot]["received_bytes"]) / int(self.dict[bot]["size"]) * 100
        completed = int(position + self.dict[bot]["received_bytes"])
        speed = (self.dict[bot]["received_bytes"]-sz)
        if speed != 0:
            tm = (int(self.dict[bot]["size"])-int(self.dict[bot]["received_bytes"])-position) / speed
        else:
            tm = 99999
        eta = utcnow() + datetime.timedelta(seconds=tm)

        speed = int(speed/1024)
        (self.dict[bot]["down"].status, self.dict[bot]["down"].progress, self.dict[bot]["down"].completed, 
            self.dict[bot]["down"].eta, self.dict[bot]["down"].timeleft)= 'Downloading...', percentage, completed, eta, tm
        #workaround for occasionnal empty packages
        if speed:
            self.dict[bot]["down"].speed = speed
        self.dict[bot]["down"].save()

        sz = self.dict[bot]["received_bytes"]
        if percentage >=100:
            self.DCCconnections_dict[bot].disconnect()
            return ""
        time.sleep(1)
    log("Monitoring stoped").write()
Пример #4
0
def DCC_deamonthread(c, server, nickname, hist, down, size=0):
    """
    If a server connection fails, there is no point in checking the queue for further downloads;
    There, we try to reconnect as soon as the connection timed out.
    To be able to interrupt the connection attempt loop, we use the signal listener and pass the server connection
    """
    botqueue = main.queuedict[server+c.bot] = Queue()
    i=1    
    while True:
        try:
            c.connect(server, 6667, nickname)
            c.start()
            break
        except irc.client.ServerConnectionError as x:
            log("error (%s)" % i + str(x)).write()
            hist.status, hist.time, hist.sizeraw = "Error during connection (%d)" % i, utcnow(), size
            hist.save()
            down.status = "Connecting to server... (%d)" % (i+1)
            down.save()
            i+=1
            if not botqueue.empty():
                mystring = botqueue.get()
                if "cancel" in mystring:
                    views.manage_queue(down)
                    break
Пример #5
0
 def on_whoisactually(self, c, e):
     #this event contains our public IP address
     for x in e.arguments:
         self.externalip = re.findall( r'[0-9]+(?:\.[0-9]+){3}', x )
         if self.externalip:
             self.externalip = self.externalip[0]
             log("External IP obtained from IRC server: %s" % self.externalip).write()
             break
Пример #6
0
 def on_dcc_disconnect(self, connection, event):
     self.file.close()
     self.upnp.deleteportmapping(self.eport, 'TCP')
     log("Portmapping for port %d deleted" % self.eport).write()
     log("DCC connection closed").write()
     try:
         self.connection.quit()
     except:
         pass
Пример #7
0
def interactive(channel, command):
    # 获取原tty属性
    oldtty = termios.tcgetattr(sys.stdin)

    try:
        # 设置 tty 的属性
        tty.setraw(sys.stdin.fileno())
        tty.setcbreak(sys.stdin.fileno())
        channel.settimeout(0.0)

        # ssh连接进入主机后 执行命令 比如: 要进入docker 容器
        if command != "":
            channel.send(command + "\r")

        tm = 2
        input_cmd = ""

        while True:
            rlist, wlist, errlist = select.select([channel, sys.stdin], [], [])
            # 从标准输入和socket 获取数据然后写入标准输出
            if channel in rlist:
                try:
                    if tm > 0:
                        time.sleep(0.2)
                        tm = tm - 1
                    r = channel.recv(256)
                    output_string = u(r)

                    # 如果返回的长度为 0 (就是没有返回), 或者 返回的是exit 就退出程序(使用与进入第二层:比如在远程主机,进入了docker)
                    if len(output_string) == 0 or output_string == '\r\nexit\r\n':
                        sys.stdout.write('\r\nWelcome back again, Bye!\r\n')
                        break

                    (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode="a")
                    logger.debug("{out_string: %s}" % [output_string])
                    logger.removeHandler(fh)

                    ishow = filter.filter_channel(output_string)
                    if ishow == True:
                        sys.stdout.write(output_string)
                        sys.stdout.flush()
                except socket.timeout:
                    pass
            # 从标准输入获取输入的字符:然后,处理输入,对输入进行过滤
            if sys.stdin in rlist:
                input_string = funkey(stdinput=sys.stdin)
                # 命令过滤
                input_string, input_cmd = filter.filter_stdin(input_string=input_string, input_cmd=input_cmd)
                # 把输入的字符发送给 远程ssh (准确的说是:经过过滤过的输入)
                channel.send(input_string)
    except Exception as e:
        fe = traceback.format_exc()
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_error'], log_fmode="a")
        logger.error("{ error }:%s \n %s" %(e, fe))
        logger.removeHandler(fh)
    finally:
        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
Пример #8
0
 def on_dccchat(self, c, e):
     log("dccchat").write()
     if len(e.arguments) != 2:
         return
     args = e.arguments[1].split()
     if len(args) == 4:
         try:
             address = ip_numstr_to_quad(args[2])
             port = int(args[3])
         except ValueError:
             return
         self.dcc_connect(address, port)
Пример #9
0
 def on_privnotice(self, c, e):
     bot = e.source.nick
     a = e.arguments[0].split(":", 1)
     log(a).write()
     if "invalid pack number" in str(a).lower():
         self.DCCconnections_dict[bot].disconnect()
         self.dict[bot]["hist"].status, self.dict[bot]["hist"].time = "Dead link from the search engine", utcnow()
         self.dict[bot]["down"].status, self.dict[bot]["down"].active = "Invalid pack number", False
         self.dict[bot]["down"].save()
         self.dict[bot]["hist"].save()            
         log("Discarding download due to invalid pack number, proceeding to next item in queue if existing.").write()
         print ("3")
         views.manage_queue(self.dict[bot]["down"])
Пример #10
0
def xdcc(resume=False, **kwargs):
    """
    when this function is called, every check has been made and the download has to be launched;
    a new bot has to be created as well as a new Download_Ongoing item;
    One bot corresponds to one server connection instance;
    One bot can have multiple DCC connections, thus handling multiple downloads    
    the History item is created for easy access, but saved only when download is finished, e.g
    completed/interrupted/canceled
    """
    down = hist = None #these are the two database objects
    irc.client.ServerConnection.buffer_class.encoding = 'latin-1'
    if resume:
        #resume = True
        log("Resume = True").write()
        down = kwargs["down_obj"]
        down.status, down.active ="Connecting to server...", True
        try:
            hist = Download_History.objects.filter(down.server).latest("id")
            if hist.attempts:
                hist.attempts+=1
        except:
            hist = Download_History(filename=kwargs["filename"]) 
    if not "filename" in kwargs:
        #direct file transfer between two IRCapp users
        server = "irc.rizon.net"# I know, pretty arbitrary, we'll make this configurable in a future version (config.ini probably)
        nickname = kwargs["nick"]
        down = Download_Ongoing(filename="Direct file transfer enabled", 
            server=server, username=nickname, status="Connecting to server...", active=False)
        hist = Download_History()  
        log("Direct = True").write()
        c = DCCReceive(direct=True, nickname=nickname, password=kwargs["pw"], down=down, hist=hist)
        t = threading.Thread(target=DCC_deamonthread, args=(c, server, nickname, hist, down))
    else:
        if not resume:
            #regular download, create new database objects
            down = Download_Ongoing(filename=kwargs["filename"], status="Connecting to server...", active=True)
            hist = Download_History(filename=kwargs["filename"])    
        size, server, channel, xdccbot, xdccrequest = (kwargs["size"], kwargs["server"],
            kwargs["channel"], kwargs["username"], kwargs["package_number"])
        msg = "xdcc send #%s" % xdccrequest
        down.server, down.channel, down.username, down.package_number = server, channel, xdccbot, xdccrequest
        c = DCCReceive(bot=xdccbot, msg=msg, channel=channel, size=size, filename=kwargs["filename"], down=down, hist=hist)        
        #anonymous nickname
        nickname = ''.join(random.choice(string.ascii_lowercase) for i in range(8))
        t = threading.Thread(target=DCC_deamonthread, args=(c, server, nickname, hist, down, size))
    down.save()
    t.daemon=True
    t.start()
Пример #11
0
def login():
    try:
        host, port, username, password, cmd = auth.auth()

        tran = paramiko.Transport((host, port))
        tran.start_client()
        tran.auth_password(username, password)

        # 打开一个通道
        chan = tran.open_session()
        # 终端配置: 类型,大小
        t = configs.CONFIG['term']
        ptype = configs.CONFIG['type'][t]
        term_size = os.get_terminal_size()
        w = term_size.columns
        h = term_size.lines
        # 获取一个终端
        chan.get_pty(term=ptype, width=w, height=h)
        # 激活器
        chan.invoke_shell()

        interactive.interactive(chan, cmd)

        chan.close()
        tran.close()
    except Exception as e:
        ef = traceback.format_exc()
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_error'],
                                log_fmode="a")
        logger.error("{ error }:%s \n %s" % (e, ef))
        logger.removeHandler(fh)
Пример #12
0
def DCC_deamonthread(c, server, nickname, upload):
    botqueue = main.queuedict[server+c.bot] = Queue()
    i=1    
    while True:
        try:
            c.connect(server, 6667, nickname)
            c.start()
            break
        except irc.client.ServerConnectionError as x:
            log("error (%s)" % i + str(x)).write()
            upload.status, upload.active = "Error during connection", False
            upload.save()
            i+=1
            if not botqueue.empty():
                mystring = botqueue.get()
                if "cancel" in mystring:
                    upload.delete()
                    break
Пример #13
0
def startapp():
    '''this "main" is application entry'''
    try:
        trigger.triggerman(protect=True)
        login.login()
    except Exception as e:
        ef = traceback.format_exc()
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_error'],
                                log_fmode="a")
        logger.error("{ error }:%s \n %s" % (e, ef))
        logger.removeHandler(fh)
Пример #14
0
 def on_welcome(self, connection, event, first=True):
     if self.direct:
         self.dict[self.bot]["down"].status = "Waiting for direct file transfer"
         self.dict[self.bot]["down"].save()
         print("bot launched for direct file transfer")
     else:
         print("bot launched for %s" % self.bot)
         self.dict[self.bot]["down"].status, self.dict[self.bot]["down"].sizeraw = (
             "Waiting for package (in queue)...", self.dict[self.bot]["size"]) 
         self.dict[self.bot]["down"].save()
     s=threading.Timer(0, self.signal_listener, [connection, event])
     s.daemon=True
     s.start()
     if first and not self.direct:      
         connection.join(self.dict[self.bot]["channel"])
         #must join mg-chat channel to download on moviegods
         if "moviegods" in self.dict[self.bot]["channel"]:
             connection.join("#MG-CHAT")
             log("Channel #mg-chat joined to be able to download").write()
         connection.privmsg(self.bot, self.dict[self.bot]["msg"])
         log("Channel joined (%s) and package requested" % self.dict[self.bot]["channel"]).write()
Пример #15
0
def select():
    # http://www.cnblogs.com/starof/p/4703820.html
    # curses.wrapper(screen_init) 这个函数会初始化 stdscr = initscr() 返回一个window对象:stdscr
    # 把 stdscr 传递给 函数 screen_init(stdscr) 的第一个参数:stdscr
    # screen_init(stdscr) 中的 stdscr 只是一个用于接受 wrapper的 window 对象的形式参数
    position = curses.wrapper(screen_init)
    (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode='a')

    host_id = position['y']*2 + position['x']
    #logger.debug("{position: %s host id: %s}" %(position, host_id))
    logger.removeHandler(fh)
    return host_id
Пример #16
0
    def process(self, c, e, resume=False):
        #"When receiving a file with DCC, accept it"
        downloads_dir = directory()
        bot = e.source.nick
        try:
            connection = self.dcc_connect(self.ip, self.port, "raw")
        except irc.client.DCCConnectionError as e:
            log('Couldn\'t connect to DCC peer: %s' % e).write()
            self.dict[bot]["hist"].status, self.dict[bot]["hist"].time = "Peer connection error", utcnow()
            self.dict[bot]["hist"].save()            
            views.manage_queue(self.dict[bot]["down"])
            return ""
        if resume:
            self.dict[bot]["file"] = open(os.path.join(downloads_dir, self.dict[bot]["filename"]), 'ab')
            self.dict[bot]["down"].filename, self.dict[bot]["down"].status = (
                self.dict[bot]["filename"], "Resuming download...")
            log('Resuming download of %s' % self.dict[bot]["filename"]).write()
        else:
            self.dict[bot]["file"] = open(os.path.join(downloads_dir, self.dict[bot]["filename"]), 'wb')
            self.dict[bot]["down"].filename, self.dict[bot]["down"].status, self.dict[bot]["down"].sizeraw = (
                self.dict[bot]["filename"], "Starting download...", self.dict[bot]["size"])            
            log('Starting download of %s' % self.dict[bot]["filename"]).write()

        self.DCCconnections_dict[bot] = connection
        self.dict[bot]["hist"].time = utcnow()
        self.dict[bot]["down"].save()
        t = threading.Timer(0, monitoring, [self, connection, bot, int(self.dict[bot]["position"])])
        t.start()
        s=threading.Timer(0, self.retry_pack, [connection, bot])
        s.daemon=True
        s.start()
Пример #17
0
def screen_init(stdscr):
    (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode='a')
    stdscr.clear()
    stdscr.refresh()
    stdscr.scrollok(1)
    #height, width = stdscr.getmaxyx()
    #logger.debug("{height: %s width: %s screen }" %(height, width))
    curses.start_color()
    # 设置颜色对 下面设置了 3 个颜色对 黑底白字 黑底红字 黑底青蓝字
    curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
    curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)
    curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK)

    # 这个部分不需要 每次都改变,只需要显示一次,不刷新就不会消失
    stdscr.addstr(3, 33, "日志查看器", curses.color_pair(3))
    stdscr.addstr(6, 10, "请选择要查看日志的项目:", curses.color_pair(1))

    lines = int(len(configs.HOSTS)/2)
    position = {"x":0, "y":0}
    change_color(stdscr, position, lines)
    while True:
        # 获取键盘输入
        key = stdscr.getch()
        #logger.debug("{key: %s key type: %s color: %s}" % ([key], type(key), position))
        if key == 259 and position['y'] > 0:
            position['y'] = position['y'] - 1
        elif key == 258 and position['y'] < lines - 1:
            position['y'] = position['y'] + 1
        elif key == 260 and position['x'] > 0:
            position['x'] = position['x'] - 1
        elif key == 261 and position['x'] < 1:
            position['x'] = position['x'] + 1

        # 如果是方向键 就改变 颜色
        if key in [258, 259, 260, 261]:
            change_color(stdscr, position, lines)
        # 如果是确定键 就跳出循环 返回位置信息
        elif key == 10:
            #logger.debug("{key: %s type: %s}" % ([key], type(key)))
            break
        # 如果输入: q/Q 表示退出
        elif key == ord('q') or key == ord('Q'):
            stdscr.refresh()
            curses.endwin()
            logger.removeHandler(fh)
            sys.exit(0)

    stdscr.refresh()
    curses.endwin()
    logger.removeHandler(fh)
    return position
Пример #18
0
def getinfo(querystring, pn=0):
    """
    internal purpose only, not a view
    """
    #for normal search
    try:
        #normal search
        par = {"q" : querystring, "pn" : pn}
        data = requests.get("http://ixirc.com/api/", params=par)
    except:
        log("Couldn't access ixirc search engine, exiting").write()
        return "Couldn't access ixirc search engine, is there a problem with your internet connexion?"

    data = json.loads(data.text)

    if data["c"] == 0:
        log("No match for %s on the search engine" % querystring).write()
        return "No match for “%s” on the search engine" % querystring

    try:
        num = len(data["results"])
        for result in data["results"][:]:
            #print (result["cname"], result["cid"])
            if testresult(result) is False:
                data["results"].remove(result)
                #quick download impossible
    except:
        #quick download impossible
        return "No match for “%s” on the search engine" % querystring

    if len(data["results"]) == 0:
        return "No match for “%s” on the search engine" % querystring

    results = data["results"]

    response = {"results" : results, "num" :  num, "pn" : pn}

    return response
Пример #19
0
    def prepupnp(self):
        """
        prep upnp
        """
        self.upnp = miniupnpc.UPnP()

        self.upnp.discoverdelay = 200

        try:
            ndevices = self.upnp.discover()
            print (ndevices, 'device(s) detected')
            # select an igd
            self.upnp.selectigd()
            """
            check database for previous port mapping ;
            check if port mapping still exist ; if so, delete it
            
            if check database for port mapping:
                try:
                    u.deleteportmapping(port, 'TCP')
                except NoSuchEntryInArray:
                    print("port mapping already deleted")
            """        
            # display information about the IGD and the internet connection
            externalipaddress = self.upnp.externalipaddress()
            print (self.upnp.statusinfo(), self.upnp.connectiontype())

            self.eport = self.dcc.localport

            # find a free port for the redirection
            r = self.upnp.getspecificportmapping(self.eport, 'TCP')
            while r != None and self.eport < 65536:
	            self.eport = self.eport + 1
	            r = self.upnp.getspecificportmapping(self.eport, 'TCP')

            log('trying to redirect %s port %u TCP => %s port %u TCP' % (externalipaddress, self.eport, self.upnp.lanaddr, self.dcc.localport)).write()

            b = self.upnp.addportmapping(self.eport, 'TCP', self.upnp.lanaddr, self.dcc.localport,
                                'UPnP IGD Tester port %u' % self.eport, '')
            if b:
	            log('Success').write()

            else:
	            log('Failed').write()

        except Exception as e:
            log('UPnP exception :', e).write()    
Пример #20
0
def auth():
    try:
        host_id = select_host.select()
        # (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode="a")
        # logger.debug("{host id: %s}" % host_id)
        # logger.removeHandler(fh)
        host, port, username, password, cmd = confirm_host(host_id)

        return (host, port, username, password, cmd)
    except Exception as e:
        ef = traceback.format_exc()
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_error'],
                                log_fmode="a")
        logger.error("{ error }:%s \n %s" % (e, ef))
        logger.removeHandler(fh)
Пример #21
0
def deny_cmd(input_cmd):
    is_allow = True
    cmd_deny = configs.CONFIG['cmd_deny']
    for deny in cmd_deny:
        r = re.findall(deny, input_cmd)
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'],
                                log_fmode="a")
        #logger.debug("{from: %s re.findall: %s result: %s}" % ([input_cmd], [deny], [r]))
        logger.removeHandler(fh)
        if r != []:
            is_allow = False

    if is_allow == False:
        print("\r\n %s :是 - 禁止使用的命令 \r\n" % [input_cmd])
        return_string = configs.KEYS['BACKSPACE'] * len(
            input_cmd) + configs.KEYS['ENTER']
        return_cmd = ""
        return return_string, return_cmd
    else:
        return None, None
Пример #22
0
def allow_cmd(input_cmd):
    is_allow = False
    # 过滤命令: 只允许通过的
    cmd_allow = configs.CONFIG['cmd_allow']
    for allow in cmd_allow:
        r = re.findall(allow, input_cmd)
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'],
                                log_fmode="a")
        #logger.debug("{from: %s re.findall: %s result: %s}" % ([input_cmd], [allow], [r]))
        logger.removeHandler(fh)
        if r != []:
            is_allow = True

    if is_allow == False:
        print("\r\n %s : 不是 - 允许使用的命令 ( 这玩意儿有 bug , 找作者!!! ) \r\n" %
              [input_cmd])
        return_string = configs.KEYS['BACKSPACE'] * len(
            input_cmd) + configs.KEYS['ENTER']
        return_cmd = ""
        return return_string, return_cmd
    else:
        return None, None
Пример #23
0
 def on_dcc_disconnect(self, connection, event, bot=""):
     for key, value in self.DCCconnections_dict.items():
         if value == connection:
             bot = key
             break
     try:
         self.dict[bot]["file"].close()
     except:
         bot = bot
     if self.dict[bot]["stop"]:
         return ""        
     if self.dict[bot]["cancel"] == False:
         (self.dict[bot]["down"].status, self.dict[bot]["down"].progress, self.dict[bot]["down"].speed, 
             self.dict[bot]["down"].progress, self.dict[bot]["down"].eta) = "Extracting...", None, None, None, None
         self.dict[bot]["down"].save()
         tot = self.dict[bot]["received_bytes"]+self.dict[bot]["position"]
         log("Received file (%d bytes)." % tot  ).write()
         log("Size (%d bytes)." % int(self.dict[bot]["size"]) ).write()
         percdone = tot/int(self.dict[bot]["size"])
         duration = (utcnow() - self.dict[bot]["hist"].time)
         average = int(self.dict[bot]["size"])/1024/duration.total_seconds()
         (self.dict[bot]["hist"].filename, self.dict[bot]["hist"].status, self.dict[bot]["hist"].average, 
             self.dict[bot]["hist"].duration, self.dict[bot]["hist"].time, self.dict[bot]["hist"].sizeraw) = (self.dict[bot]["filename"],
             "Downloaded", round(average, 0), duration, utcnow(), self.dict[bot]["size"])
         self.dict[bot]["hist"].save()
         if os.path.exists(os.path.join(directory(), self.dict[bot]["filename"])):
             #added to prevent extracting incomplete files (internet connection interrupted)
             if percdone > 99/100:
                 untar(os.path.join(directory(), self.dict[bot]["filename"]), 
                     self.dict[bot]["filename"], self.dict[bot]["down"], self.dict[bot]["hist"])
                 return ""
         
         self.dict[bot]["down"].status = "Error during file transfer"
         self.dict[bot]["down"].save()
         self.dict[bot]["hist"].status, self.dict[bot]["hist"].time = "Error during file transfer", utcnow()
         self.dict[bot]["hist"].save()
         log("Error during file transfer. Completed percentage: %d" % int(percdone*100) ).write()
         print ("2")
         views.manage_queue(self.dict[bot]["down"])
         return ""
     else:
         self.dict[bot]["cancel"] = False
         views.manage_queue(self.dict[bot]["down"])
         return ""
Пример #24
0
def funkey(stdinput):
    input_string = stdinput.read(1)

    (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'],
                            log_fmode="a")
    logger.debug("{ stdin.read(1): %s}" % [input_string])
    logger.removeHandler(fh)

    if len(input_string) == 0:
        return "break"
    # 如果是功能键
    if input_string == "\x1b":
        input_string = input_string + stdinput.read(2)

        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'],
                                log_fmode="a")
        logger.debug("{ stdin.read(2): %s}" % [input_string])
        logger.removeHandler(fh)

        # 只允许上下键 通过 其他的全当回车用
        if input_string in (configs.KEYS['UP_ARROW'],
                            configs.KEYS['DOWN_ARROW']):
            #input_string = "\t"
            return input_string
        # elif input_string in (configs.KEYS['LEFT_ARROW']):
        #     #print("\r\n 不支持:左键,你输入的是:%s \r\n" %[input_string])
        #     input_string = 'left_arrow' + input_string
        #     return input_string
        # elif input_string in (configs.KEYS['RIGHT_ARROW']):
        #     #print("\r\n 不支持:右键,你输入的是:%s \r\n" %[input_string])
        #     input_string = 'right_arrow' + input_string
        #     return input_string
        elif input_string in configs.KEYS['KEY_DENY1']:
            print(
                "\r\n 不支持:左右键,功能键 = (F1~F12、Home、Insert、Delete、End、PageUp、PageDown),你输入的是:%s \r\n"
                % [input_string])
            input_string = "\r"
            return input_string
        else:
            input_string = input_string + stdinput.read(1)
            if input_string in configs.KEYS['KEY_DENY2']:
                print(
                    "\r\n 不支持:左右键,功能键 = (F1~F12、Home、Insert、Delete、End、PageUp、PageDown),你输入的是:%s \r\n"
                    % [input_string])
                input_string = "\r"
                return input_string
            else:
                input_string = input_string + stdinput.read(1)
                if input_string in configs.KEYS['KEY_DENY3']:
                    print(
                        "\r\n 不支持:左右键,功能键 = (F1~F12、Home、Insert、Delete、End、PageUp、PageDown),你输入的是:%s \r\n"
                        % [input_string])
                    input_string = "\r"
                    return input_string
                else:
                    print(
                        "\r\n 不支持:左右键,功能键 = (F1~F12、Home、Insert、Delete、End、PageUp、PageDown),你输入的是:%s \r\n"
                        % [input_string])
                    input_string = "\r"
                    return input_string
    else:
        return input_string
Пример #25
0
 def on_kill(self, connection, event):
     log("booted").write
Пример #26
0
 def on_disconnect(self, connection, event):
     print ("disconnected")
     log("disconnected").write()
Пример #27
0
 def on_nicknameinuse(self, c, e):
     c.nick(c.get_nickname() + "_")
     log("Nickname already used. Now using %s" % (c.get_nickname() + "_")).write()
Пример #28
0
 def on_disconnect(self, connection, event):
     log("disconnected").write()
     self.upload.delete()
Пример #29
0
def untar(completefile, filename, down, hist):
    log("Extracting the file...").write()
    log(completefile + ' ' + filename).write()
    # tar file to extract
    theTarFile = completefile

    # tar file path to extract
    extractTarPath = os.path.join(directory(), '_UNPACK_' + splitext(filename)[0])
    if tarfile.is_tarfile(theTarFile):
        # extract all contents
        try:
            tfile = tarfile.open(theTarFile)
            tfile.extractall(extractTarPath)
            tfile.close()
            os.remove(theTarFile)
            #extract rar files
            x=0
            completefile = False
            #this test is added in case some txt is extracted with the folder
            while not os.path.isdir(os.path.join(extractTarPath, os.listdir(extractTarPath)[x])):
                #sometimes the file extracted is the final file, no futher rar extraction needed; in this case, test for it's size and finish
                if os.path.getsize(os.path.join(extractTarPath, os.listdir(extractTarPath)[x])) > 90/100*hist.sizeraw:
                    completefile = True
                    break
                x+=1
            if not completefile:
                origin = os.path.join(extractTarPath, os.listdir(extractTarPath)[x])
                log(origin).write()
                for fl in os.listdir(origin):
                    shutil.move(os.path.join(origin, fl), extractTarPath)
                shutil.rmtree(origin)
                for archivefile in os.listdir(extractTarPath):
                    if ".rar" in archivefile:
                        arch_ref = rarfile.RarFile(os.path.join(extractTarPath, archivefile),'r')
                        arch_ref.extractall(extractTarPath)
                #remove rest
                for fl in os.listdir(extractTarPath):
                    ext = splitext(fl)[1].lower()
                    pathToDelete = os.path.join(extractTarPath, fl)
                    if os.path.isdir(pathToDelete):
                    # Do not delete non-empty dirs, could contain useful files.
                        try:
                            os.rmdir(pathToDelete);
                        except OSError as ex:
                            if ex.errno == errno.ENOTEMPTY:
                                log("Did not delete non-empty directory : %s" %  pathToDelete).write()
                            else:
                                log("An error occurred deleting directory : %s" % pathToDelete).write()
                    else:
                        if ext[:2] == '.r' or ext in ['.sfv', '.nfo', '.png', '.jpg'] or 'sample' in fl:
                            os.remove(os.path.join(extractTarPath, fl))
            #remove UNPACK from name when done
            os.rename(extractTarPath, os.path.join(directory(), splitext(filename)[0]))
        except Exception as e:
            log("An error occured during file extraction : %s" % e).write()
            hist.status, hist.time = "Error during file extraction", utcnow()
            down.status, down.sizeraw, down.active = "Error during file extraction", None, False
            down.save()
            hist.save()
            print ("4")
            views.manage_queue(down)
            return ""

    else:
        log(theTarFile + " is not a tarfile.").write()


    down.status, down.sizeraw, down.active = "Downloaded and extracted properly", None, False
    hist.status, hist.time = "Downloaded and extracted properly", utcnow()
    hist.save()
    down.save()
    print ("5")
    views.manage_queue(down)
    return ""
Пример #30
0
 def on_dcc_connect(self, c, e):
     t = threading.Timer(0, upload_monitoring, [self, c, self.upload])
     t.start()    
     log("connection made with %s" % self.nickname).write()
     self.file = open(self.filename, 'rb')
     self.sendBlock()
Пример #31
0
def read_log(request):
    log_file = open(log().my_log)
    response = HttpResponse(content=log_file)
    response['Content-Type'] = 'text/plain'
    log_file.close()
    return response        
Пример #32
0
def quickinfo(querystring):
    """
    internal purpose only, not a view
    """
    #for quickdownload
    i = 0
    total = []
    while True:
        try:
            par = { 'q' : querystring, 'pn' : i }
            data = requests.get("http://ixirc.com/api/", params=par)
        except:
            log("Couldn't access ixirc search engine, exiting.").write()
            return "Couldn't access ixirc search engine, is there a problem with your internet connexion?"

        i += 1
        data = json.loads(data.text)


        try:
            if len(data["results"]) == 0:
                #quick download impossible
                return ""
        except:
            #quick download impossible
            return ""

        query = querystring.split(" ")
        quality_list = ['MAXI', 'EXCE', 'GOOD', 'NORM']
        quality_words = ['bluray', '1080', '720', 'hd']
        quality_index =  quality_list.index(Quick_Download.objects.latest('id').priority)        
        for x in data["results"][:]:
            test = True
            for element in query:
                if not element in x["name"].lower():
                    test = False
                    print (element, x["name"].lower())
            if Quick_Download_Contains.objects.all().count() > 0:
                for obj in Quick_Download_Contains.objects.all():
                    if not str(obj.contains).lower() in x["name"].lower():
                        test = False
            if Quick_Download_Excludes.objects.all().count() > 0:
                for obj in Quick_Download_Excludes.objects.all():
                    if str(obj.excludes).lower() in x["name"].lower():
                        test = False
                       
            #first loop through all the keywords
            for word in quality_words[quality_index:]:
                #for each key word, loop through all the elements to find a match before doing the same for the next keyword
                if word in x["name"].lower():
                    if word == "hd":
                        #also, if word is "hd", exclude other words since x["name"] might be like "720p.HDTV"
                        for otherword in quality_words[:quality_index]:
                            if otherword in x["name"].lower():
                                test = False

                else:
                    test = False
            if test and testresult(x):
                return x               
        if not (len(data["results"]) % 30 == 1 and len(data["results"]) != 1): break
Пример #33
0
def filter_stdin(input_string, input_cmd, yesno):
    (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'],
                            log_fmode="a")
    return_cmd = input_cmd + input_string
    return_string = input_string

    logger.debug("{input_string: %s input_cmd: %s}" %
                 ([input_string], [input_cmd]))

    # yes or no
    note = yesno
    # logger.debug("{3 note.yn: %s}" % note.yn)
    # if note.yn == True and input_string != 'q':
    #     return_cmd = input_cmd
    #     return_string = input_string
    #     logger.debug("{4 note.yn: %s}" % note.yn)
    #     logger.removeHandler(fh)
    #     return return_string, return_cmd

    if note.yn == True:
        return_cmd = input_cmd
        return_string = input_string
        if input_string == "q" or input_string == "n":
            note.yn = False
        # logger.debug("{5 note.yn: %s}" % note.yn)
        logger.removeHandler(fh)
        return return_string, return_cmd

    # 匹配 退格键
    if input_string == configs.KEYS['BACKSPACE']:
        return_cmd = input_cmd[:-1]
        #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
        logger.removeHandler(fh)
        return return_string, return_cmd

    # 匹配 tab键, 向上键, 向下键
    if input_string == configs.KEYS['TAB']:
        return_cmd = input_cmd
        logger.removeHandler(fh)
        return return_string, return_cmd

    # 匹配 向上键, 向下键
    if input_string in (configs.KEYS['UP_ARROW'], configs.KEYS['DOWN_ARROW']):
        return_cmd = input_cmd
        logger.removeHandler(fh)
        return return_string, return_cmd

    if input_string == configs.KEYS['ENTER']:
        # 退出处理
        special_cmd.exit(input_cmd)

        if input_cmd == "":
            return_cmd = input_cmd
            #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
            logger.removeHandler(fh)
            return return_string, return_cmd

        # s, c = special_cmd.help_cmd(input_cmd)
        # # 不等None 就是匹配到 help 命令
        # if s != None:
        #     return_string = s
        #     return_cmd = c
        #     #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
        #     logger.removeHandler(fh)
        #     return  return_string, return_cmd

        s, c = allow_cmd(input_cmd)
        # 不等None 就是没有匹配到 允许的命令 (清除命令输入,然后回车)
        if s != None:
            return_string = s
            return_cmd = c
            #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
            logger.removeHandler(fh)
            return return_string, return_cmd

        s, c = deny_cmd(input_cmd)
        # 不等None 就是匹配到了 不允许的命令 (清除命令输入,然后回车)
        if s != None:
            return_string = s
            return_cmd = c
            #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
            logger.removeHandler(fh)
            return return_string, return_cmd

        return_cmd = ""
        #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
        logger.removeHandler(fh)
        return return_string, return_cmd

    #logger.debug("{return_string: %s return_cmd: %s}" % ([return_string], [return_cmd]))
    logger.removeHandler(fh)
    return return_string, return_cmd
Пример #34
0
def interactive(channel, command):
    # 获取原tty属性
    oldtty = termios.tcgetattr(sys.stdin)

    try:
        # 设置 tty 的属性
        tty.setraw(sys.stdin.fileno())
        tty.setcbreak(sys.stdin.fileno())
        channel.settimeout(1.5)

        # ssh连接进入主机后 执行命令 比如: 要进入docker 容器
        if command != "":
            channel.send(command + "\r")

        # 获取终端大小
        term_size = os.get_terminal_size()
        w_old = term_size.columns
        h_old = term_size.lines

        tm = 2
        input_cmd = ""
        input_string = "\r"
        note = input_handle.InputHandle()
        left_arrow_count = 0
        right_arrow_count = 0
        while True:
            # 获取终端大小
            term_size = os.get_terminal_size()
            w = term_size.columns
            h = term_size.lines
            # 如果窗口大小变了,更更改
            if w != w_old or h != h_old:
                w_old = w
                h_old = h
                # 重置 虚拟终端的大小
                channel.resize_pty(w, h)
                continue
            # 更改 channel 会发生 InterruptedError 异常。
            try:
                rlist, wlist, errlist = select.select([channel, sys.stdin], [],
                                                      [])
            except InterruptedError:
                continue

            # (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode="a")
            # logger.debug("{channel len: %s}" % dir(channel.in_buffer._buffer))
            # logger.debug("{dir(channel.recv): %s}" % help(channel.recv))
            # logger.debug("{channel : %s}" % channel.in_buffer._buffer)
            # logger.debug("{channel len: %s}" % len(channel.in_buffer._buffer))
            # logger.removeHandler(fh)

            # 从标准输入和socket 获取数据然后写入标准输出
            if channel in rlist:
                try:
                    # 启动交互 头两次等待一小会儿,然数据接受完整(为了登录时不显示 docker exec -it 进入容器这一步)
                    if tm > 0:
                        time.sleep(0.2 * tm)
                        tm = tm - 1
                    # 接收多少个字节
                    r = channel.recv(1024)

                    # tab 补全
                    if input_string == '\t' and r[:2] != b"\r\n" and r[:1] != b"\x07" and r[
                            -23:] != b"possibilities? (y or n)":
                        input_cmd = input_cmd + output.u_reconsitution(r)

                        # (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode="a")
                        # logger.debug("{input_string: %s r[:1]: %s }" % ([input_string], r[:1]))
                        # logger.debug("{input_cmd: %s r[:3]: %s }" % ([input_cmd], r[:3]))
                        # logger.removeHandler(fh)

                    # (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode="a")
                    # logger.debug("{1 note.yn: %s}" % note.yn)
                    recv_list = r.split(b'\r\n')
                    # logger.debug("{rlist : %s}" % recv_list)
                    # logger.debug("{r length : %s}" % len(r))
                    # logger.debug("{rlist[-1] : %s}" % rlist[-1])

                    # 更改 补全提示状态
                    if recv_list[-1] != b"--More--" and len(r) < 1024:
                        note.yn = False
                    elif recv_list[-1] == b"--More--":
                        note.yn = True
                    # logger.debug("{6 note.yn : %s}" % note.yn)
                    # logger.removeHandler(fh)

                    if input_string == "\t" and r[
                            -23:] == b"possibilities? (y or n)":
                        note.yn = True

                    # (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_debug'], log_fmode="a")
                    # logger.debug("{2 note.yn: %s}" % note.yn)
                    # logger.removeHandler(fh)

                    status = output.output(r)
                    if status == "exit":
                        break
                    elif status == None:
                        pass
                except socket.timeout:
                    pass
            # 从标准输入获取输入的字符:然后,处理输入,对输入进行过滤
            if sys.stdin in rlist:
                input_string = funkey(stdinput=sys.stdin)
                if input_string == "break":
                    break
                # elif input_string == "left_arrow\x1b[D":
                #     left_arrow_count = left_arrow_count + 1
                #     input_string = '\x1b[D'
                # elif input_string == "right_arrow\x1b[C":
                #     right_arrow_count = right_arrow_count + 1
                #     input_string = '\x1b[C'
                #
                # if len(input_cmd) == 0:
                #     pass
                # else:
                #     cursor_position = left_arrow_count - right_arrow_count
                #     if cursor_position <= 0:
                #         cursor_position = 0
                #     elif cursor_position >= len(input_cmd):
                #         cursor_position = len(input_cmd)
                #
                #     if input_string == "\x08" and cursor_position < len(input_cmd):
                #         input_cmd = input_cmd[:-(cursor_position + 1)] + input_cmd[-cursor_position:]

                # 命令过滤
                input_string, input_cmd = filter.filter_stdin(
                    input_string=input_string, input_cmd=input_cmd, yesno=note)
                # 把输入的字符发送给 远程ssh (准确的说是:经过过滤过的输入)
                channel.send(input_string)
    except Exception as e:
        fe = traceback.format_exc()
        (logger, fh) = logs.log(log_file=configs.CONFIG['logfile_error'],
                                log_fmode="a")
        logger.error("{ error }:%s \n %s" % (e, fe))
        logger.removeHandler(fh)
    finally:
        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
Пример #35
0
 def signal_listener(self, connection, event):
     botqueue = main.queuedict[connection.server+self.bot]
     while True:
         while botqueue.empty():
             time.sleep(0.2)
         mystring = botqueue.get()
         bot = self.bot
         print ("Signal received on %s: %s" % (connection.server+':'+bot, mystring))
         if "stop" in mystring:
             #this is the case when there are no more DCCconnections or when IRCapp shutdown is pressed
             self.dict[bot]["stop"] = True
             self.reactor.disconnect_all()
             break
         elif "cancel" in mystring:
             if self.direct:
                 self.reactor.disconnect_all()
                 del botqueue
                 self.dict[bot]["down"].delete()
                 return
             #connection.privmsg(bot, "xdcc cancel")                       
             self.dict[bot]["cancel"] = True
             try:
                 self.DCCconnections_dict[bot].disconnect()
             except KeyError:
                 #DCC connection not yet established
                 self.on_dcc_disconnect(connection, event, bot=bot)
         else:
             mylist = [x for x in mystring.split(",")]
             if mylist[0] == "queue_item":
                 connection.privmsg(bot, "xdcc send #%s" % mylist[3])
                 log("New package requested").write()
                 hist = Download_History(filename=mylist[1], sizeraw=mylist[2]) 
                 self.dict[bot]["filename"], self.dict[bot]["size"], self.dict[bot]["received_bytes"] = mylist[1], mylist[2], 0
                 (self.dict[bot]["down"].status, self.dict[bot]["down"].progress, self.dict[bot]["down"].completed, 
                     self.dict[bot]["down"].eta, self.dict[bot]["down"].timeleft, self.dict[bot]["down"].active)= 'New package requested', 0, 0, None, None, True                    
                 self.dict[bot]["down"].filename, self.dict[bot]["down"].sizeraw, self.dict[bot]["down"].package_number = (
                     mylist[1], mylist[2], mylist[3])
                 self.dict[bot]["down"].save()
                 self.dict[bot]["hist"] = hist
             else:
                 main.queuedict[connection.server+mylist[1]] = Queue()
                 #remaining case : the bot has to join another channel of this server
                 #since we're about to open a new DCCconnection, create new download object
                 down = Download_Ongoing(filename=mylist[3], status="Requesting package...", active=True,
                     server=self.dict[bot]["down"].server, channel=mylist[0], username=mylist[1], package_number=mylist[2], sizeraw=mylist[4])
                 hist = Download_History(filename=mylist[3], sizeraw=mylist[4])   
                 down.save()
                 bot = self.bot = mylist[1]
                 data = {
                     "received_bytes" : 0,
                     "cancel" : False,
                     "stop" : False,
                     "position" : 0,
                     "down" : down,
                     "hist" : hist,
                     "filename" : mylist[3],
                     "size" : mylist[4]
                 }
                 self.dict[bot] = data                  
                 connection.join(mylist[0])
                 connection.privmsg(mylist[1], "xdcc send #%s" % mylist[2])
                 if "moviegods" in mylist[0]:
                     connection.join("#MG-CHAT")                    
                 log("Channel joined (%s) and package requested" % mylist[0]).write()
                 self.on_welcome(connection, event, first=False)