cobweb-launcher 1.1.22__tar.gz → 1.2.0__tar.gz

{cobweb-launcher-1.1.22/cobweb_launcher.egg-info → cobweb-launcher-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cobweb-launcher
-Version: 1.1.22
+Version: 1.2.0
 Summary: spider_hole
 Home-page: https://github.com/Juannie-PP/cobweb
 Author: Juannie-PP

cobweb-launcher-1.2.0/cobweb/__init__.py

@@ -0,0 +1,2 @@
+from .launchers import LauncherAir, LauncherPro
+from .constant import CrawlerModel

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/base/__init__.py

@@ -1,7 +1,7 @@
 from .common_queue import Queue
 from .response import Response
 from .request import Request
-from .item import BaseItem
+from .item import BaseItem, ConsoleItem
 from .seed import Seed
 
 from .log import logger

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/base/item.py

@@ -37,3 +37,10 @@ class BaseItem(metaclass=Item):
     @property
     def table(self):
         return self.Data.__name__
+
+
+class ConsoleItem(BaseItem):
+
+    __TABLE__ = "console"
+    __FIELDS__ = "data"
+

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/constant.py

@@ -30,6 +30,24 @@ class DealModel:
 
 class LogTemplate:
 
+    console_item = """
+    ----------------------- start - console pipeline -----------------
+            种子详情 \n{seed_detail}
+            解析详情 \n{parse_detail}
+    ----------------------- end  - console pipeline ------------------
+    """
+
+    launcher_air_polling = """
+    ----------------------- start - 轮训日志: {task} -----------------
+            内存队列 
+                种子数:  {doing_len}
+                待消费:  {todo_len}
+                已消费:  {done_len}
+            存储队列 
+                待上传:  {upload_len}
+    ----------------------- end  - 轮训日志: {task} ------------------
+    """
+
     launcher_pro_polling = """
 ----------------------- start - 轮训日志: {task} -----------------
         内存队列 
@@ -69,4 +87,8 @@ class LogTemplate:
         response 
             status        :    {status} \n{response}
 ------------------------------------------------------------------
-"""
+"""
+
+    @staticmethod
+    def log_info(item: dict) -> str:
+        return "\n".join([" " * 12 + f"{str(k).ljust(14)}:    {str(v)}" for k, v in item.items()])

cobweb-launcher-1.2.0/cobweb/crawlers/__init__.py

@@ -0,0 +1 @@
+from .crawler import Crawler

cobweb-launcher-1.1.22/cobweb/crawlers/base_crawler.py → cobweb-launcher-1.2.0/cobweb/crawlers/crawler.py

@@ -1,39 +1,52 @@
+import json
 import threading
 import time
-
+import traceback
 from inspect import isgenerator
 from typing import Union, Callable, Mapping
 
-from cobweb.base import Queue, Seed, BaseItem, Request, Response, logger
 from cobweb.constant import DealModel, LogTemplate
-from cobweb.utils import download_log_info
-from cobweb import setting
+from cobweb.base import (
+    Queue, 
+    Seed, 
+    BaseItem, 
+    Request, 
+    Response, 
+    ConsoleItem,
+    logger
+)
 
 
 class Crawler(threading.Thread):
 
     def __init__(
             self,
-            upload_queue: Queue,
-            custom_func: Union[Mapping[str, Callable]],
+            stop: threading.Event,
+            pause: threading.Event,
             launcher_queue: Union[Mapping[str, Queue]],
+            custom_func: Union[Mapping[str, Callable]],
+            thread_num: int,
+            max_retries: int
     ):
         super().__init__()
 
-        self.upload_queue = upload_queue
+        self._stop = stop
+        self._pause = pause
+        self._new = launcher_queue["new"]
+        self._todo = launcher_queue["todo"]
+        self._done = launcher_queue["done"]
+        self._upload = launcher_queue["upload"]
+
         for func_name, _callable in custom_func.items():
             if isinstance(_callable, Callable):
                 self.__setattr__(func_name, _callable)
 
-        self.launcher_queue = launcher_queue
-
-        self.spider_thread_num = setting.SPIDER_THREAD_NUM
-        self.max_retries = setting.SPIDER_MAX_RETRIES
+        self.thread_num = thread_num
+        self.max_retries = max_retries
 
     @staticmethod
     def request(seed: Seed) -> Union[Request, BaseItem]:
-        stream = True if setting.DOWNLOAD_MODEL else False
-        yield Request(seed.url, seed, stream=stream, timeout=5)
+        yield Request(seed.url, seed, timeout=5)
 
     @staticmethod
     def download(item: Request) -> Union[Seed, BaseItem, Response, str]:
@@ -42,39 +55,43 @@ class Crawler(threading.Thread):
 
     @staticmethod
     def parse(item: Response) -> BaseItem:
-        pass
+        upload_item = item.to_dict
+        upload_item["text"] = item.response.text
+        yield ConsoleItem(item.seed, data=json.dumps(upload_item, ensure_ascii=False))
 
-    def get_seed(self) -> Seed:
-        return self.launcher_queue['todo'].pop()
+    # def get_seed(self) -> Seed:
+    #     return self._todo.pop()
 
     def distribute(self, item, seed):
         if isinstance(item, BaseItem):
-            self.upload_queue.push(item)
+            self._upload.push(item)
         elif isinstance(item, Seed):
-            self.launcher_queue['new'].push(item)
+            self._new.push(item)
         elif isinstance(item, str) and item == DealModel.poll:
-            self.launcher_queue['todo'].push(seed)
+            self._todo.push(seed)
         elif isinstance(item, str) and item == DealModel.done:
-            self.launcher_queue['done'].push(seed)
+            self._done.push(seed)
         elif isinstance(item, str) and item == DealModel.fail:
             seed.params.seed_status = DealModel.fail
-            self.launcher_queue['done'].push(seed)
+            self._done.push(seed)
         else:
             raise TypeError("yield value type error!")
 
     def spider(self):
-        while True:
-            seed = self.get_seed()
+        while not self._stop.is_set():
+
+            seed = self._todo.pop()
 
             if not seed:
+                time.sleep(1)
                 continue
 
             elif seed.params.retry >= self.max_retries:
                 seed.params.seed_status = DealModel.fail
-                self.launcher_queue['done'].push(seed)
+                self._done.push(seed)
                 continue
 
-            seed_detail_log_info = download_log_info(seed.to_dict)
+            seed_detail_log_info = LogTemplate.log_info(seed.to_dict)
 
             try:
                 request_iterators = self.request(seed)
@@ -105,7 +122,7 @@ class Crawler(threading.Thread):
                                     seed_version=seed.params.seed_version,
                                     identifier=seed.identifier or "",
                                     status=download_item.response,
-                                    response=download_log_info(download_item.to_dict)
+                                    response=LogTemplate.log_info(download_item.to_dict)
                                 ))
                                 parse_iterators = self.parse(download_item)
                                 if not isgenerator(parse_iterators):
@@ -122,21 +139,22 @@ class Crawler(threading.Thread):
 
                 if not iterator_status:
                     raise ValueError("request/download/parse function yield value error!")
-
             except Exception as e:
                 logger.info(LogTemplate.download_exception.format(
                     detail=seed_detail_log_info,
                     retry=seed.params.retry,
                     priority=seed.params.priority,
                     seed_version=seed.params.seed_version,
-                    identifier=seed.identifier or "", exception=e
+                    identifier=seed.identifier or "",
+                    exception=''.join(traceback.format_exception(type(e), e, e.__traceback__))
                 ))
                 seed.params.retry += 1
-                self.launcher_queue['todo'].push(seed)
+                self._todo.push(seed)
             finally:
                 time.sleep(0.1)
+        logger.info("spider thread close")
 
     def run(self):
-        for index in range(self.spider_thread_num):
+        for index in range(self.thread_num):
             threading.Thread(name=f"spider_{index}", target=self.spider).start()
 

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/launchers/__init__.py

@@ -1,2 +1,2 @@
-from .launcher import Launcher
+from .launcher_air import LauncherAir
 from .launcher_pro import LauncherPro

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/launchers/launcher.py

@@ -15,15 +15,16 @@ class Launcher(threading.Thread):
     __DOING__ = {}
 
     __CUSTOM_FUNC__ = {
-        "download": None,
-        "download_midware": None,
-        "parse": None,
+        # "download": None,
+        # "request": None,
+        # "parse": None,
     }
 
     __LAUNCHER_QUEUE__ = {
         "new": Queue(),
         "todo": Queue(),
         "done": Queue(),
+        "upload": Queue()
     }
 
     __LAUNCHER_FUNC__ = [
@@ -76,9 +77,13 @@ class Launcher(threading.Thread):
         self._done_queue_max_size = setting.DONE_QUEUE_MAX_SIZE
         self._upload_queue_max_size = setting.UPLOAD_QUEUE_MAX_SIZE
 
+        self._spider_thread_num = setting.SPIDER_MAX_RETRIES
+        self._spider_max_retries = setting.SPIDER_THREAD_NUM
+
         self._done_model = setting.DONE_MODEL
+        self._task_model = setting.TASK_MODEL
 
-        self._upload_queue = Queue()
+        # self._upload_queue = Queue()
 
     @property
     def start_seeds(self):
@@ -121,7 +126,7 @@ class Launcher(threading.Thread):
         use case:
             from cobweb.base import Request, Response
             @launcher.download
-            def download(item: Response) -> BaseItem:
+            def parse(item: Response) -> BaseItem:
                ...
                yield xxxItem(seed, **kwargs)
         """
@@ -133,6 +138,33 @@ class Launcher(threading.Thread):
         for seed in seeds:
             self.__DOING__.pop(seed, None)
 
+    def _execute(self):
+        for func_name in self.__LAUNCHER_FUNC__:
+            threading.Thread(name=func_name, target=getattr(self, func_name)).start()
+            time.sleep(2)
+
+    def run(self):
+        threading.Thread(target=self._execute_heartbeat).start()
+
+        self._Crawler(
+            stop=self._stop, pause=self._pause,
+            launcher_queue=self.__LAUNCHER_QUEUE__,
+            custom_func=self.__CUSTOM_FUNC__,
+            thread_num = self._spider_thread_num,
+            max_retries = self._spider_max_retries
+        ).start()
+
+        self._Pipeline(
+            stop=self._stop, pause=self._pause,
+            upload=self.__LAUNCHER_QUEUE__["upload"],
+            done=self.__LAUNCHER_QUEUE__["done"],
+            upload_size=self._upload_queue_max_size,
+            wait_seconds=self._upload_queue_wait_seconds
+        ).start()
+
+        self._execute()
+        self._polling()
+
     def _execute_heartbeat(self):
         pass
 
@@ -151,52 +183,6 @@ class Launcher(threading.Thread):
     def _delete(self):
         pass
 
-    def _execute(self):
-        for func_name in self.__LAUNCHER_FUNC__:
-            threading.Thread(name=func_name, target=getattr(self, func_name)).start()
-            time.sleep(2)
-
     def _polling(self):
+        pass
 
-        check_emtpy_times = 0
-
-        while not self._stop.is_set():
-
-            queue_not_empty_count = 0
-
-            for q in self.__LAUNCHER_QUEUE__.values():
-                if q.length != 0:
-                    queue_not_empty_count += 1
-
-            if self._pause.is_set() and queue_not_empty_count != 0:
-                self._pause.clear()
-                self._execute()
-
-            elif queue_not_empty_count == 0:
-                check_emtpy_times += 1
-            else:
-                check_emtpy_times = 0
-
-            if check_emtpy_times > 2:
-                check_emtpy_times = 0
-                self.__DOING__ = {}
-                self._pause.set()
-
-    def run(self):
-        threading.Thread(target=self._execute_heartbeat).start()
-
-        self._Crawler(
-            upload_queue=self._upload_queue,
-            custom_func=self.__CUSTOM_FUNC__,
-            launcher_queue=self.__LAUNCHER_QUEUE__,
-        ).start()
-
-        self._Pipeline(
-            upload_queue=self._upload_queue,
-            done_queue=self.__LAUNCHER_QUEUE__["done"],
-            upload_queue_size=self._upload_queue_max_size,
-            upload_wait_seconds=self._upload_queue_wait_seconds
-        ).start()
-
-        self._execute()
-        self._polling()

cobweb-launcher-1.2.0/cobweb/launchers/launcher_air.py

@@ -0,0 +1,88 @@
+import time
+
+from cobweb.constant import LogTemplate
+from cobweb.base import logger
+from .launcher import Launcher
+
+
+class LauncherAir(Launcher):
+
+    def _scheduler(self):
+        if self.start_seeds:
+            self.__LAUNCHER_QUEUE__['todo'].push(self.start_seeds)
+
+    def _insert(self):
+        while not self._pause.is_set():
+            seeds = {}
+            status = self.__LAUNCHER_QUEUE__['new'].length < self._new_queue_max_size
+            for _ in range(self._new_queue_max_size):
+                seed = self.__LAUNCHER_QUEUE__['new'].pop()
+                if not seed:
+                    break
+                seeds[seed.to_string] = seed.params.priority
+            if seeds:
+                self.__LAUNCHER_QUEUE__['todo'].push(seeds)
+            if status:
+                time.sleep(self._new_queue_wait_seconds)
+
+    def _delete(self):
+        while not self._pause.is_set():
+            seeds = []
+            status = self.__LAUNCHER_QUEUE__['done'].length < self._done_queue_max_size
+
+            for _ in range(self._done_queue_max_size):
+                seed = self.__LAUNCHER_QUEUE__['done'].pop()
+                if not seed:
+                    break
+                seeds.append(seed.to_string)
+
+            if seeds:
+                self._remove_doing_seeds(seeds)
+
+            if status:
+                time.sleep(self._done_queue_wait_seconds)
+
+    def _polling(self):
+
+        check_emtpy_times = 0
+
+        while not self._stop.is_set():
+
+            queue_not_empty_count = 0
+            pooling_wait_seconds = 30
+
+            for q in self.__LAUNCHER_QUEUE__.values():
+                if q.length != 0:
+                    queue_not_empty_count += 1
+
+            if queue_not_empty_count == 0:
+                pooling_wait_seconds = 3
+                if self._pause.is_set():
+                    check_emtpy_times = 0
+                    if not self._task_model:
+                        logger.info("Done! Ready to close thread...")
+                        self._stop.set()
+                elif check_emtpy_times > 2:
+                    self.__DOING__ = {}
+                    self._pause.set()
+                else:
+                    logger.info(
+                        "check whether the task is complete, "
+                        f"reset times {3 - check_emtpy_times}"
+                    )
+                    check_emtpy_times += 1
+            elif self._pause.is_set():
+                self._pause.clear()
+                self._execute()
+            else:
+                logger.info(LogTemplate.launcher_air_polling.format(
+                    task=self.task,
+                    doing_len=len(self.__DOING__.keys()),
+                    todo_len=self.__LAUNCHER_QUEUE__['todo'].length,
+                    done_len=self.__LAUNCHER_QUEUE__['done'].length,
+                    upload_len=self.__LAUNCHER_QUEUE__['upload'].length,
+                ))
+
+            time.sleep(pooling_wait_seconds)
+
+

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/launchers/launcher_pro.py

@@ -3,19 +3,19 @@ import threading
 
 from cobweb.db import RedisDB
 from cobweb.base import Seed, logger
-from cobweb.launchers import Launcher
 from cobweb.constant import DealModel, LogTemplate
+from .launcher import Launcher
 
 
 class LauncherPro(Launcher):
 
     def __init__(self, task, project, custom_setting=None, **kwargs):
         super().__init__(task, project, custom_setting, **kwargs)
-        self._todo = "{%s:%s}:todo" % (project, task)
-        self._done = "{%s:%s}:done" % (project, task)
-        self._fail = "{%s:%s}:fail" % (project, task)
-        self._heartbeat = "heartbeat:%s_%s" % (project, task)
-        self._reset_lock = "lock:reset:%s_%s" % (project, task)
+        self._todo_key = "{%s:%s}:todo" % (project, task)
+        self._done_key = "{%s:%s}:done" % (project, task)
+        self._fail_key = "{%s:%s}:fail" % (project, task)
+        self._heartbeat_key = "heartbeat:%s_%s" % (project, task)
+        self._reset_lock_key = "lock:reset:%s_%s" % (project, task)
         self._db = RedisDB()
 
         self._heartbeat_start_event = threading.Event()
@@ -23,12 +23,12 @@ class LauncherPro(Launcher):
 
     @property
     def heartbeat(self):
-        return self._db.exists(self._heartbeat)
+        return self._db.exists(self._heartbeat_key)
 
     def _execute_heartbeat(self):
         while not self._stop.is_set():
             if self._heartbeat_start_event.is_set():
-                self._db.setex(self._heartbeat, 3)
+                self._db.setex(self._heartbeat_key, 3)
             time.sleep(2)
 
     def _reset(self):
@@ -39,15 +39,15 @@ class LauncherPro(Launcher):
         while not self._pause.is_set():
             reset_wait_seconds = 30
             start_reset_time = int(time.time())
-            if self._db.lock(self._reset_lock, t=120):
+            if self._db.lock(self._reset_lock_key, t=120):
                 if not self.heartbeat:
                     self._heartbeat_start_event.set()
 
                 _min = -int(time.time()) + self._seed_reset_seconds \
                     if self.heartbeat or not init else "-inf"
 
-                self._db.members(self._todo, 0, _min=_min, _max="(0")
-                self._db.delete(self._reset_lock)
+                self._db.members(self._todo_key, 0, _min=_min, _max="(0")
+                self._db.delete(self._reset_lock_key)
 
                 ttl = 120 - int(time.time()) + start_reset_time
                 reset_wait_seconds = max(ttl, 1)
@@ -61,14 +61,14 @@ class LauncherPro(Launcher):
         if self.start_seeds:
             self.__LAUNCHER_QUEUE__['todo'].push(self.start_seeds)
         while not self._pause.is_set():
-            if not self._db.zcount(self._todo, 0, "(1000"):
+            if not self._db.zcount(self._todo_key, 0, "(1000"):
                 time.sleep(self._scheduler_wait_seconds)
                 continue
             if self.__LAUNCHER_QUEUE__['todo'].length >= self._todo_queue_size:
                 time.sleep(self._todo_queue_full_wait_seconds)
                 continue
             members = self._db.members(
-                self._todo, int(time.time()),
+                self._todo_key, int(time.time()),
                 count=self._todo_queue_size,
                 _min=0, _max="(1000"
             )
@@ -90,7 +90,7 @@ class LauncherPro(Launcher):
                     break
                 seeds[seed.to_string] = seed.params.priority
             if seeds:
-                self._db.zadd(self._todo, seeds, nx=True)
+                self._db.zadd(self._todo_key, seeds, nx=True)
             if status:
                 time.sleep(self._new_queue_wait_seconds)
 
@@ -102,7 +102,7 @@ class LauncherPro(Launcher):
             if self.__DOING__:
                 refresh_time = int(time.time())
                 seeds = {k:-refresh_time - v / 1000 for k, v in self.__DOING__.items()}
-                self._db.zadd(self._todo, item=seeds, xx=True)
+                self._db.zadd(self._todo_key, item=seeds, xx=True)
             time.sleep(30)
 
     def _delete(self):
@@ -124,13 +124,13 @@ class LauncherPro(Launcher):
                 else:
                     seeds.append(seed.to_string)
             if seeds:
-                self._db.zrem(self._todo, *seeds)
+                self._db.zrem(self._todo_key, *seeds)
                 self._remove_doing_seeds(seeds)
             if s_seeds:
-                self._db.done([self._todo, self._done], *s_seeds)
+                self._db.done([self._todo_key, self._done_key], *s_seeds)
                 self._remove_doing_seeds(s_seeds)
             if f_seeds:
-                self._db.done([self._todo, self._fail], *f_seeds)
+                self._db.done([self._todo_key, self._fail_key], *f_seeds)
                 self._remove_doing_seeds(f_seeds)
 
             if status:
@@ -141,32 +141,73 @@ class LauncherPro(Launcher):
         while not self._stop.is_set():
             queue_not_empty_count = 0
             pooling_wait_seconds = 30
+
             for q in self.__LAUNCHER_QUEUE__.values():
                 if q.length != 0:
                     queue_not_empty_count += 1
-            if self._pause.is_set():
+
+            if queue_not_empty_count == 0:
+                pooling_wait_seconds = 3
+                if self._pause.is_set():
+                    check_emtpy_times = 0
+                    if not self._task_model:
+                        logger.info("Done! Ready to close thread...")
+                        self._stop.set()
+                elif not self._db.zcount(self._todo_key, _min=0, _max="(1000") and check_emtpy_times > 2:
+                    self.__DOING__ = {}
+                    self._pause.set()
+                else:
+                    logger.info(
+                        "check whether the task is complete, "
+                        f"reset times {3 - check_emtpy_times}"
+                    )
+                    check_emtpy_times += 1
+            elif self._pause.is_set():
                 self._pause.clear()
                 self._execute()
-            elif queue_not_empty_count == 0:
-                pooling_wait_seconds = 5
-                check_emtpy_times += 1
             else:
-                check_emtpy_times = 0
-
-            if not self._db.zcount(self._todo, _min=0, _max="(1000") and check_emtpy_times > 2:
-                check_emtpy_times = 0
-                self.__DOING__ = {}
-                self._pause.set()
-
-            if not self._pause.is_set():
                 logger.info(LogTemplate.launcher_pro_polling.format(
                     task=self.task,
                     doing_len=len(self.__DOING__.keys()),
                     todo_len=self.__LAUNCHER_QUEUE__['todo'].length,
                     done_len=self.__LAUNCHER_QUEUE__['done'].length,
-                    redis_seed_count=self._db.zcount(self._todo, "-inf", "+inf"),
-                    redis_todo_len=self._db.zcount(self._todo, 0, "(1000"),
-                    redis_doing_len=self._db.zcount(self._todo, "-inf", "(0"),
-                    upload_len=self._upload_queue.length
+                    redis_seed_count=self._db.zcount(self._todo_key, "-inf", "+inf"),
+                    redis_todo_len=self._db.zcount(self._todo_key, 0, "(1000"),
+                    redis_doing_len=self._db.zcount(self._todo_key, "-inf", "(0"),
+                    upload_len=self.__LAUNCHER_QUEUE__['upload'].length,
                 ))
+
             time.sleep(pooling_wait_seconds)
+            # if self._pause.is_set():
+            #     self._pause.clear()
+            #     self._execute()
+            #
+            # elif queue_not_empty_count == 0:
+            #     pooling_wait_seconds = 5
+            #     check_emtpy_times += 1
+            # else:
+            #     check_emtpy_times = 0
+            #
+            # if not self._db.zcount(self._todo, _min=0, _max="(1000") and check_emtpy_times > 2:
+            #     check_emtpy_times = 0
+            #     self.__DOING__ = {}
+            #     self._pause.set()
+            #
+            # time.sleep(pooling_wait_seconds)
+            #
+            # if not self._pause.is_set():
+            #     logger.info(LogTemplate.launcher_pro_polling.format(
+            #         task=self.task,
+            #         doing_len=len(self.__DOING__.keys()),
+            #         todo_len=self.__LAUNCHER_QUEUE__['todo'].length,
+            #         done_len=self.__LAUNCHER_QUEUE__['done'].length,
+            #         redis_seed_count=self._db.zcount(self._todo, "-inf", "+inf"),
+            #         redis_todo_len=self._db.zcount(self._todo, 0, "(1000"),
+            #         redis_doing_len=self._db.zcount(self._todo, "-inf", "(0"),
+            #         upload_len=self.__LAUNCHER_QUEUE__['upload'].length,
+            #     ))
+            # elif not self._task_model:
+            #     self._stop.set()
+
+        logger.info("Done! Ready to close thread...")
+

cobweb-launcher-1.2.0/cobweb/pipelines/__init__.py

@@ -0,0 +1,3 @@
+from .pipeline import Pipeline
+from .pipeline_console import Console
+from .pipeline_loghub import Loghub

cobweb-launcher-1.1.22/cobweb/pipelines/base_pipeline.py → cobweb-launcher-1.2.0/cobweb/pipelines/pipeline.py

@@ -9,16 +9,20 @@ class Pipeline(threading.Thread, ABC):
 
     def __init__(
             self,
-            done_queue: Queue,
-            upload_queue: Queue,
-            upload_queue_size: int,
-            upload_wait_seconds: int
+            stop: threading.Event,
+            pause: threading.Event,
+            upload: Queue, done: Queue,
+            upload_size: int,
+            wait_seconds: int
     ):
         super().__init__()
-        self.done_queue = done_queue
-        self.upload_queue = upload_queue
-        self.upload_queue_size = upload_queue_size
-        self.upload_wait_seconds = upload_wait_seconds
+        self._stop = stop
+        self._pause = pause
+        self._upload = upload
+        self._done = done
+
+        self.upload_size = upload_size
+        self.wait_seconds = wait_seconds
 
     @abstractmethod
     def build(self, item: BaseItem) -> dict:
@@ -29,13 +33,13 @@ class Pipeline(threading.Thread, ABC):
         pass
 
     def run(self):
-        while True:
-            status = self.upload_queue.length < self.upload_queue_size
+        while not self._stop.is_set():
+            status = self._upload.length < self.upload_size
             if status:
-                time.sleep(self.upload_wait_seconds)
+                time.sleep(self.wait_seconds)
             data_info, seeds = {}, []
-            for _ in range(self.upload_queue_size):
-                item = self.upload_queue.pop()
+            for _ in range(self.upload_size):
+                item = self._upload.pop()
                 if not item:
                     break
                 data = self.build(item)
@@ -49,6 +53,8 @@ class Pipeline(threading.Thread, ABC):
                     logger.info(e)
                     status = False
                 if status:
-                    self.done_queue.push(seeds)
+                    self._done.push(seeds)
+
+        logger.info("upload pipeline close!")
 
 

cobweb-launcher-1.2.0/cobweb/pipelines/pipeline_console.py

@@ -0,0 +1,24 @@
+import json
+
+from cobweb.base import ConsoleItem, logger
+from cobweb.constant import LogTemplate
+from cobweb.pipelines import Pipeline
+
+
+class Console(Pipeline):
+
+    def build(self, item: ConsoleItem):
+        return {
+            "seed": item.seed.to_dict,
+            "data": item.to_dict
+        }
+
+    def upload(self, table, datas):
+        for data in datas:
+            parse_detail = LogTemplate.log_info(data["data"])
+            if len(parse_detail) > 500:
+                parse_detail = parse_detail[:500] + " ...\n" + " " * 12 + "-- Text is too long and details are omitted!"
+            logger.info(LogTemplate.console_item.format(
+                seed_detail=LogTemplate.log_info(data["seed"]),
+                parse_detail=parse_detail
+            ))

cobweb-launcher-1.1.22/cobweb/pipelines/loghub_pipeline.py → cobweb-launcher-1.2.0/cobweb/pipelines/pipeline_loghub.py

@@ -6,7 +6,7 @@ from cobweb.pipelines import Pipeline
 from aliyun.log import LogClient, LogItem, PutLogsRequest
 
 
-class LoghubPipeline(Pipeline):
+class Loghub(Pipeline):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/setting.py

@@ -30,8 +30,8 @@ OSS_MIN_UPLOAD_SIZE = 1024
 # 采集器选择
 CRAWLER = "cobweb.crawlers.Crawler"
 
-# 数据上传链路
-PIPELINE = "cobweb.pipelines.loghub_pipeline.LoghubPipeline"
+# 数据存储链路
+PIPELINE = "cobweb.pipelines.pipeline_console.Console"
 
 
 # Launcher 等待时间
@@ -52,12 +52,12 @@ UPLOAD_QUEUE_MAX_SIZE = 100  # upload队列长度
 # DONE_MODEL IN (0, 1), 种子完成模式
 DONE_MODEL = 0   # 0:种子消费成功直接从队列移除，失败则添加至失败队列；1:种子消费成功添加至成功队列，失败添加至失败队列
 
-# DOWNLOAD_MODEL IN (0, 1), 下载模式
-DOWNLOAD_MODEL = 0  # 0: 通用下载；1:文件下载
-
 # spider
 SPIDER_THREAD_NUM = 10
 SPIDER_MAX_RETRIES = 5
 
+# 任务模式
+TASK_MODEL = 0  # 0:单次，1:常驻
+
 # 文件下载响应类型过滤
-FILE_FILTER_CONTENT_TYPE = ["text/html", "application/xhtml+xml"]
+# FILE_FILTER_CONTENT_TYPE = ["text/html", "application/xhtml+xml"]

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb/utils/tools.py

@@ -38,5 +38,5 @@ def dynamic_load_class(model_info):
     raise TypeError()
 
 
-def download_log_info(item:dict) -> str:
-    return "\n".join([" " * 12 + f"{str(k).ljust(14)}:    {str(v)}" for k, v in item.items()])
+# def download_log_info(item:dict) -> str:
+#     return "\n".join([" " * 12 + f"{str(k).ljust(14)}:    {str(v)}" for k, v in item.items()])

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0/cobweb_launcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cobweb-launcher
-Version: 1.1.22
+Version: 1.2.0
 Summary: spider_hole
 Home-page: https://github.com/Juannie-PP/cobweb
 Author: Juannie-PP

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/cobweb_launcher.egg-info/SOURCES.txt

@@ -13,18 +13,19 @@ cobweb/base/request.py
 cobweb/base/response.py
 cobweb/base/seed.py
 cobweb/crawlers/__init__.py
-cobweb/crawlers/base_crawler.py
-cobweb/crawlers/file_crawler.py
+cobweb/crawlers/crawler.py
 cobweb/db/__init__.py
 cobweb/db/redis_db.py
 cobweb/exceptions/__init__.py
 cobweb/exceptions/oss_db_exception.py
 cobweb/launchers/__init__.py
 cobweb/launchers/launcher.py
+cobweb/launchers/launcher_air.py
 cobweb/launchers/launcher_pro.py
 cobweb/pipelines/__init__.py
-cobweb/pipelines/base_pipeline.py
-cobweb/pipelines/loghub_pipeline.py
+cobweb/pipelines/pipeline.py
+cobweb/pipelines/pipeline_console.py
+cobweb/pipelines/pipeline_loghub.py
 cobweb/utils/__init__.py
 cobweb/utils/oss.py
 cobweb/utils/tools.py

{cobweb-launcher-1.1.22 → cobweb-launcher-1.2.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="cobweb-launcher",
-    version="1.1.22",
+    version="1.2.0",
     packages=find_packages(),
     url="https://github.com/Juannie-PP/cobweb",
     license="MIT",

cobweb-launcher-1.1.22/cobweb/__init__.py

@@ -1,2 +0,0 @@
-from .launchers import Launcher, LauncherPro
-from .constant import CrawlerModel

cobweb-launcher-1.1.22/cobweb/crawlers/__init__.py

@@ -1,2 +0,0 @@
-from .base_crawler import Crawler
-from .file_crawler import FileCrawlerAir

cobweb-launcher-1.1.22/cobweb/crawlers/file_crawler.py

@@ -1,98 +0,0 @@
-import os
-from typing import Union
-from cobweb import setting
-from cobweb.utils import OssUtil
-from cobweb.crawlers import Crawler
-from cobweb.base import Seed, BaseItem, Request, Response
-from cobweb.exceptions import OssDBPutPartError, OssDBMergeError
-
-
-oss_util = OssUtil(is_path_style=bool(int(os.getenv("PRIVATE_LINK", 0))))
-
-
-class FileCrawlerAir(Crawler):
-
-    @staticmethod
-    def download(item: Request) -> Union[Seed, BaseItem, Response, str]:
-        seed_dict = item.seed.to_dict
-        seed_dict["bucket_name"] = oss_util.bucket
-        try:
-            seed_dict["oss_path"] = key = item.seed.oss_path or getattr(item, "oss_path")
-
-            if oss_util.exists(key):
-                seed_dict["data_size"] = oss_util.head(key).content_length
-                yield Response(item.seed, "exists", **seed_dict)
-
-            else:
-                seed_dict.setdefault("end", "")
-                seed_dict.setdefault("start", 0)
-
-                if seed_dict["end"] or seed_dict["start"]:
-                    start, end = seed_dict["start"], seed_dict["end"]
-                    item.request_setting["headers"]['Range'] = f'bytes={start}-{end}'
-
-                if not item.seed.identifier:
-                    content = b""
-                    chunk_size = oss_util.chunk_size
-                    min_upload_size = oss_util.min_upload_size
-                    seed_dict.setdefault("position", 1)
-
-                    response = item.download()
-
-                    content_type = response.headers.get("content-type", "").split(";")[0]
-                    seed_dict["data_size"] = content_length = int(response.headers.get("content-length", 0))
-
-                    if content_type and content_type in setting.FILE_FILTER_CONTENT_TYPE:
-                        """过滤响应文件类型"""
-                        response.close()
-                        seed_dict["filter"] = True
-                        seed_dict["msg"] = f"response content type is {content_type}"
-                        yield Response(item.seed, response, **seed_dict)
-
-                    elif seed_dict['position'] == 1 and min_upload_size >= content_length > 0:
-                        """过小文件标识返回"""
-                        response.close()
-                        seed_dict["filter"] = True
-                        seed_dict["msg"] = "file size is too small"
-                        yield Response(item.seed, response, **seed_dict)
-
-                    elif seed_dict['position'] == 1 and chunk_size > content_length > min_upload_size:
-                        """小文件直接下载"""
-                        for part_data in response.iter_content(chunk_size):
-                            content += part_data
-                        response.close()
-                        oss_util.put(key, content)
-                        yield Response(item.seed, response, **seed_dict)
-
-                    else:
-                        """中大文件同步分片下载"""
-                        seed_dict.setdefault("upload_id", oss_util.init_part(key).upload_id)
-
-                        for part_data in response.iter_content(chunk_size):
-                            content += part_data
-                            if len(content) >= chunk_size:
-                                upload_data = content[:chunk_size]
-                                content = content[chunk_size:]
-                                oss_util.put_part(key, seed_dict["upload_id"], seed_dict['position'], content)
-                                seed_dict['start'] += len(upload_data)
-                                seed_dict['position'] += 1
-
-                        response.close()
-
-                        if content:
-                            oss_util.put_part(key, seed_dict["upload_id"], seed_dict['position'], content)
-                        oss_util.merge(key, seed_dict["upload_id"])
-                        seed_dict["data_size"] = oss_util.head(key).content_length
-                        yield Response(item.seed, response, **seed_dict)
-
-                elif item.seed.identifier == "merge":
-                    oss_util.merge(key, seed_dict["upload_id"])
-                    seed_dict["data_size"] = oss_util.head(key).content_length
-                    yield Response(item.seed, "merge", **seed_dict)
-
-        except OssDBPutPartError:
-            yield Seed(seed_dict)
-        except OssDBMergeError:
-            yield Seed(seed_dict, identifier="merge")
-
-

cobweb-launcher-1.1.22/cobweb/pipelines/__init__.py

@@ -1,2 +0,0 @@
-from .base_pipeline import Pipeline
-from .loghub_pipeline import LoghubPipeline