Merge pull request #1 from pyload/stable

Merge

1 files changed, 218 insertions, 125 deletions

diff --git a/module/plugins/hooks/Captcha9kw.py b/module/plugins/hooks/Captcha9kw.py
index c86f92972..33ad00c49 100755
--- a/module/plugins/hooks/Captcha9kw.py
+++ b/module/plugins/hooks/Captcha9kw.py
@@ -1,168 +1,261 @@
 # -*- coding: utf-8 -*-
 
-"""
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 3 of the License,
-    or (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-    See the GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, see <http://www.gnu.org/licenses/>.
-
-    @author: mkaay, RaNaN, zoidberg
-"""
 from __future__ import with_statement
 
-from thread import start_new_thread
+import re
+
 from base64 import b64encode
-import time
+from thread import start_new_thread
+from time import sleep
 
-from module.network.RequestFactory import getURL
 from module.network.HTTPRequest import BadHeader
+from module.network.RequestFactory import getURL
 
 from module.plugins.Hook import Hook
 
 
 class Captcha9kw(Hook):
-    __name__ = "Captcha9kw"
-    __version__ = "0.09"
+    __name__    = "Captcha9kw"
+    __type__    = "hook"
+    __version__ = "0.26"
+
+    __config__ = [("activated"     , "bool"    , "Activated"                                                                       , True                                                               ),
+                  ("ssl"           , "bool"    , "Use HTTPS"                                                                       , True                                                               ),
+                  ("force"         , "bool"    , "Force captcha resolving even if client is connected"                             , True                                                               ),
+                  ("confirm"       , "bool"    , "Confirm Captcha (cost +6 credits)"                                               , False                                                              ),
+                  ("captchaperhour", "int"     , "Captcha per hour"                                                                , "9999"                                                             ),
+                  ("captchapermin" , "int"     , "Captcha per minute"                                                              , "9999"                                                             ),
+                  ("prio"          , "int"     , "Priority (max 10)(cost +0 -> +10 credits)"                                       , "0"                                                                ),
+                  ("queue"         , "int"     , "Max. Queue (max 999)"                                                            , "50"                                                               ),
+                  ("hoster_options", "string"  , "Hoster options (format: pluginname:prio=1:selfsolfe=1:confirm=1:timeout=900|...)", "ShareonlineBiz:prio=0:timeout=999 | UploadedTo:prio=0:timeout=999"),
+                  ("selfsolve"     , "bool"    , "Selfsolve (manually solve your captcha in your 9kw client if active)"            , "0"                                                                ),
+                  ("passkey"       , "password", "API key"                                                                         , ""                                                                 ),
+                  ("timeout"       , "int"     , "Timeout in seconds (min 60, max 3999)"                                           , "900"                                                              )]
+
     __description__ = """Send captchas to 9kw.eu"""
-    __config__ = [("activated", "bool", "Activated", False),
-                  ("force", "bool", "Force CT even if client is connected", True),
-                  ("https", "bool", "Enable HTTPS", False),
-                  ("confirm", "bool", "Confirm Captcha (Cost +6)", False),
-                  ("captchaperhour", "int", "Captcha per hour (max. 9999)", 9999),
-                  ("prio", "int", "Prio 1-10 (Cost +1-10)", 0),
-                  ("selfsolve", "bool",
-                   "If enabled and you have a 9kw client active only you will get your captcha to solve it (Selfsolve)",
-                   False),
-                  ("timeout", "int", "Timeout (max. 300)", 300),
-                  ("passkey", "password", "API key", "")]
-    __author_name__ = "RaNaN"
-    __author_mail__ = "RaNaN@pyload.org"
-
-    API_URL = "://www.9kw.eu/index.cgi"
+    __license__     = "GPLv3"
+    __authors__     = [("RaNaN", "RaNaN@pyload.org"),
+                       ("Walter Purcaro", "vuolter@gmail.com")]
+
+
+    API_URL = "http://www.9kw.eu/index.cgi"
+
+
+    #@TODO: Remove in 0.4.10
+    def initPeriodical(self):
+        pass
+
 
     def setup(self):
-        self.API_URL = "https" + self.API_URL if self.getConfig("https") else "http" + self.API_URL
-        self.info = {}
+        self.info = {}  #@TODO: Remove in 0.4.10
+        if self.getConfig("ssl"):
+            self.API_URL = self.API_URL.replace("http://", "https://")
 
-    def getCredits(self):
-        response = getURL(self.API_URL, get={"apikey": self.getConfig("passkey"), "pyload": "1", "source": "pyload",
-                                             "action": "usercaptchaguthaben"})
 
-        if response.isdigit():
-            self.logInfo(_("%s credits left") % response)
-            self.info["credits"] = credits = int(response)
+    def getCredits(self):
+        res = getURL(self.API_URL,
+                     get={'apikey': self.getConfig("passkey"),
+                          'pyload': "1",
+                          'source': "pyload",
+                          'action': "usercaptchaguthaben"})
+
+        if res.isdigit():
+            self.logInfo(_("%s credits left") % res)
+            credits = self.info['credits'] = int(res)
             return credits
         else:
-            self.logError(response)
+            self.logError(res)
             return 0
 
-    def processCaptcha(self, task):
-        result = None
 
-        with open(task.captchaFile, 'rb') as f:
-            data = f.read()
+    def _processCaptcha(self, task):
+        try:
+            with open(task.captchaFile, 'rb') as f:
+                data = f.read()
+
+        except IOError, e:
+            self.logError(e)
+            return
+
         data = b64encode(data)
-        self.logDebug("%s : %s" % (task.captchaFile, data))
-        if task.isPositional():
-            mouse = 1
-        else:
-            mouse = 0
-
-        response = getURL(self.API_URL, post={
-            "apikey": self.getConfig("passkey"),
-            "prio": self.getConfig("prio"),
-            "confirm": self.getConfig("confirm"),
-            "captchaperhour": self.getConfig("captchaperhour"),
-            "maxtimeout": self.getConfig("timeout"),
-            "selfsolve": self.getConfig("selfsolve"),
-            "pyload": "1",
-            "source": "pyload",
-            "base64": "1",
-            "mouse": mouse,
-            "file-upload-01": data,
-            "action": "usercaptchaupload"})
-
-        if response.isdigit():
-            self.logInfo(_("New CaptchaID from upload: %s : %s") % (response, task.captchaFile))
-
-            for _ in xrange(1, 100, 1):
-                response2 = getURL(self.API_URL, get={"apikey": self.getConfig("passkey"), "id": response,
-                                                      "pyload": "1", "source": "pyload",
-                                                      "action": "usercaptchacorrectdata"})
-
-                if response2 != "":
+        mouse = 1 if task.isPositional() else 0
+        pluginname = re.search(r'_([^_]*)_\d+.\w+', task.captchaFile).group(1)
+
+        option = {'min'           : 2,
+                  'max'           : 50,
+                  'phrase'        : 0,
+                  'numeric'       : 0,
+                  'case_sensitive': 0,
+                  'math'          : 0,
+                  'prio'          : min(max(self.getConfig("prio"), 0), 10),
+                  'confirm'       : self.getConfig("confirm"),
+                  'timeout'       : min(max(self.getConfig("timeout"), 300), 3999),
+                  'selfsolve'     : self.getConfig("selfsolve"),
+                  'cph'           : self.getConfig("captchaperhour"),
+                  'cpm'           : self.getConfig("captchapermin")}
+
+        for opt in str(self.getConfig("hoster_options").split('|')):
+
+            details = map(str.strip, opt.split(':'))
+
+            if not details or details[0].lower() != pluginname.lower():
+                continue
+
+            for d in details:
+                hosteroption = d.split("=")
+
+                if len(hosteroption) < 2 or not hosteroption[1].isdigit():
+                    continue
+
+                o = hosteroption[0].lower()
+                if o in option:
+                    option[o] = hosteroption[1]
+
+            break
+
+        post_data = {'apikey'        : self.getConfig("passkey"),
+                     'prio'          : option['prio'],
+                     'confirm'       : option['confirm'],
+                     'maxtimeout'    : option['timeout'],
+                     'selfsolve'     : option['selfsolve'],
+                     'captchaperhour': option['cph'],
+                     'captchapermin' : option['cpm'],
+                     'case-sensitive': option['case_sensitive'],
+                     'min_len'       : option['min'],
+                     'max_len'       : option['max'],
+                     'phrase'        : option['phrase'],
+                     'numeric'       : option['numeric'],
+                     'math'          : option['math'],
+                     'oldsource'     : pluginname,
+                     'pyload'        : "1",
+                     'source'        : "pyload",
+                     'base64'        : "1",
+                     'mouse'         : mouse,
+                     'file-upload-01': data,
+                     'action'        : "usercaptchaupload"}
+
+        for _i in xrange(5):
+            try:
+                res = getURL(self.API_URL, post=post_data)
+            except BadHeader, e:
+                sleep(3)
+            else:
+                if res and res.isdigit():
                     break
+        else:
+            self.logError(_("Bad upload: %s") % res)
+            return
+
+        self.logDebug(_("NewCaptchaID ticket: %s") % res, task.captchaFile)
+
+        task.data["ticket"] = res
+
+        for _i in xrange(int(self.getConfig("timeout") / 5)):
+            result = getURL(self.API_URL,
+                            get={'apikey': self.getConfig("passkey"),
+                                 'id'    : res,
+                                 'pyload': "1",
+                                 'info'  : "1",
+                                 'source': "pyload",
+                                 'action': "usercaptchacorrectdata"})
+
+            if not result or result == "NO DATA":
+                sleep(5)
+            else:
+                break
+        else:
+            self.logDebug("Could not send request: %s" % res)
+            result = None
 
-                time.sleep(3)
+        self.logInfo(_("Captcha result for ticket %s: %s") % (res, result))
+
+        task.setResult(result)
 
-            result = response2
-            task.data["ticket"] = response
-            self.logInfo("result %s : %s" % (response, result))
-            task.setResult(result)
-        else:
-            self.logError("Bad upload: %s" % response)
-            return False
 
     def newCaptchaTask(self, task):
         if not task.isTextual() and not task.isPositional():
-            return False
+            return
 
         if not self.getConfig("passkey"):
-            return False
+            return
 
         if self.core.isClientConnected() and not self.getConfig("force"):
-            return False
+            return
 
-        if self.getCredits() > 0:
-            task.handler.append(self)
-            task.setWaiting(self.getConfig("timeout"))
-            start_new_thread(self.processCaptcha, (task,))
+        credits = self.getCredits()
 
-        else:
-            self.logError(_("Your Captcha 9kw.eu Account has not enough credits"))
+        if not credits:
+            self.logError(_("Your captcha 9kw.eu account has not enough credits"))
+            return
 
-    def captchaCorrect(self, task):
-        if "ticket" in task.data:
+        queue = min(self.getConfig("queue"), 999)
+        timeout = min(max(self.getConfig("timeout"), 300), 3999)
+        pluginname = re.search(r'_([^_]*)_\d+.\w+', task.captchaFile).group(1)
 
-            try:
-                response = getURL(self.API_URL,
-                                  post={"action": "usercaptchacorrectback",
-                                        "apikey": self.getConfig("passkey"),
-                                        "api_key": self.getConfig("passkey"),
-                                        "correct": "1",
-                                        "pyload": "1",
-                                        "source": "pyload",
-                                        "id": task.data["ticket"]})
-                self.logInfo("Request correct: %s" % response)
+        for _i in xrange(5):
+            servercheck = getURL("http://www.9kw.eu/grafik/servercheck.txt")
+            if queue < re.search(r'queue=(\d+)', servercheck).group(1):
+                break
 
-            except BadHeader, e:
-                self.logError("Could not send correct request.", str(e))
+            sleep(10)
         else:
-            self.logError("No CaptchaID for correct request (task %s) found." % task)
+            self.fail(_("Too many captchas in queue"))
 
-    def captchaInvalid(self, task):
-        if "ticket" in task.data:
+        for opt in str(self.getConfig("hoster_options").split('|')):
+            details = map(str.strip, opt.split(':'))
 
-            try:
-                response = getURL(self.API_URL,
-                                  post={"action": "usercaptchacorrectback",
-                                        "apikey": self.getConfig("passkey"),
-                                        "api_key": self.getConfig("passkey"),
-                                        "correct": "2",
-                                        "pyload": "1",
-                                        "source": "pyload",
-                                        "id": task.data["ticket"]})
-                self.logInfo("Request refund: %s" % response)
+            if not details or details[0].lower() != pluginname.lower():
+                continue
 
-            except BadHeader, e:
-                self.logError("Could not send refund request.", str(e))
+            for d in details:
+                hosteroption = d.split("=")
+
+                if (len(hosteroption) > 1
+                    and hosteroption[0].lower() == 'timeout'
+                    and hosteroption[1].isdigit()):
+                    timeout = int(hosteroption[1])
+
+            break
+
+        task.handler.append(self)
+
+        task.setWaiting(timeout)
+
+        self._processCaptcha(task)
+
+
+    def _captchaResponse(self, task, correct):
+        type = "correct" if correct else "refund"
+
+        if 'ticket' not in task.data:
+            self.logDebug("No CaptchaID for %s request (task: %s)" % (type, task))
+            return
+
+        passkey = self.getConfig("passkey")
+
+        for _i in xrange(3):
+            res = getURL(self.API_URL,
+                         get={'action' : "usercaptchacorrectback",
+                              'apikey' : passkey,
+                              'api_key': passkey,
+                              'correct': "1" if correct else "2",
+                              'pyload' : "1",
+                              'source' : "pyload",
+                              'id'     : task.data["ticket"]})
+
+            self.logDebug("Request %s: %s" % (type, res))
+
+            if res == "OK":
+                break
+
+            sleep(5)
         else:
-            self.logError("No CaptchaID for not correct request (task %s) found." % task)
+            self.logDebug("Could not send %s request: %s" % (type, res))
+
+
+    def captchaCorrect(self, task):
+        self._captchaResponse(task, True)
+
+
+    def captchaInvalid(self, task):
+        self._captchaResponse(task, False)