watchmen-collector-kernel 16.4.9__py3-none-any.whl → 16.4.10__py3-none-any.whl

watchmen_collector_kernel/common/__init__.py

@@ -1,2 +1,3 @@
 from .constants import CHANGE_RECORD_ID, TENANT_ID, IS_MERGED, LEFT_BRACE, RIGHT_BRACE, COMMA, \
 	IS_POSTED, CHANGE_JSON_ID, WAVE, IS_FINISHED, IS_EXTRACTED, MODEL_TRIGGER_ID
+from .settings import ask_lock_clean_interval, ask_lock_clean_timeout, ask_partial_size

watchmen_collector_kernel/common/settings.py

@@ -0,0 +1,32 @@
+from pydantic import BaseSettings
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+
+class CollectorSettings(BaseSettings):
+	LOCK_CLEAN_INTERVAL: int = 60
+	LOCK_CLEAN_TIMEOUT: int = 3600
+	PARTIAL_SIZE: int = 10000
+
+	class Config:
+		# secrets_dir = '/var/run'
+		env_file = '.env'
+		env_file_encoding = 'utf-8'
+		case_sensitive = True
+
+
+collector_settings = CollectorSettings()
+logger.info(f'Collector settings[{collector_settings.dict()}].')
+
+
+def ask_lock_clean_interval() -> int:
+	return collector_settings.LOCK_CLEAN_INTERVAL
+
+
+def ask_lock_clean_timeout() -> int:
+	return collector_settings.LOCK_CLEAN_TIMEOUT
+
+
+def ask_partial_size() -> int:
+	return collector_settings.PARTIAL_SIZE

watchmen_collector_kernel/model/__init__.py

@@ -9,7 +9,9 @@ from .trigger_model import TriggerModel
 from .trigger_table import TriggerTable
 
 from .change_data_record import ChangeDataRecord
+from .change_data_record_history import ChangeDataRecordHistory
 from .change_data_json import ChangeDataJson
+from .change_data_json_history import ChangeDataJsonHistory
 
 from .condition import construct_conditions, Condition, ConditionJoint, ConditionExpression, \
 	ConditionJointConjunction

watchmen_collector_kernel/model/change_data_json_history.py

@@ -0,0 +1,6 @@
+from .change_data_json import ChangeDataJson
+
+
+class ChangeDataJsonHistory(ChangeDataJson):
+	pass
+

watchmen_collector_kernel/model/change_data_record_history.py

@@ -0,0 +1,5 @@
+from .change_data_record import ChangeDataRecord
+
+
+class ChangeDataRecordHistory(ChangeDataRecord):
+	pass

watchmen_collector_kernel/model/scheduled_task.py

@@ -1,4 +1,6 @@
-from typing import Dict, List
+from typing import Dict, List, Optional, Union
+
+from watchmen_utilities import ArrayHelper
 
 from watchmen_model.common import TenantBasedTuple, ScheduledTaskId, Storable
 from pydantic import BaseModel
@@ -16,6 +18,22 @@ class Dependence(Storable, BaseModel):
 	objectId: str
 
 
+def construct_dependence(dependence: Union[Dependence, Dict]) -> Optional[Dependence]:
+	if dependence is None:
+		return None
+	elif isinstance(dependence, Dependence):
+		return dependence
+	else:
+		return Dependence(**dependence)
+
+
+def construct_depend_on(depend_on: Optional[List[Union[Dependence, Dict]]]) -> Optional[List[Dependence]]:
+	if depend_on is None:
+		return None
+	else:
+		return ArrayHelper(depend_on).map(lambda x: construct_dependence(x)).to_list()
+
+
 class ScheduledTask(TenantBasedTuple, BaseModel):
 	taskId: ScheduledTaskId
 	resourceId: str  # global unique, monotonous increase
@@ -28,3 +46,8 @@ class ScheduledTask(TenantBasedTuple, BaseModel):
 	isFinished: bool
 	result: Dict
 
+	def __setattr__(self, name, value):
+		if name == 'dependOn':
+			super().__setattr__(name, construct_depend_on(value))
+		else:
+			super().__setattr__(name, value)

watchmen_collector_kernel/model/scheduled_task_history.py

@@ -0,0 +1,5 @@
+from .scheduled_task import ScheduledTask
+
+
+class ScheduledTaskHistory(ScheduledTask):
+	pass

watchmen_collector_kernel/service/lock_clean.py

@@ -4,6 +4,7 @@ from threading import Thread
 
 from time import sleep
 
+from watchmen_collector_kernel.common import ask_lock_clean_interval, ask_lock_clean_timeout
 from watchmen_collector_kernel.storage import get_competitive_lock_service
 from watchmen_meta.common import ask_meta_storage
 
@@ -12,7 +13,8 @@ class LockClean:
 
 	def __init__(self):
 		self.lock_service = get_competitive_lock_service(ask_meta_storage())
-		self.cleanInterval = 60
+		self.cleanInterval = ask_lock_clean_interval()
+		self.cleanTimeout = ask_lock_clean_timeout()
 
 	def run(self):
 		try:
@@ -25,7 +27,7 @@ class LockClean:
 			self.restart()
 
 	def clean_lock(self):
-		query_time = datetime.now() - timedelta(minutes=120)
+		query_time = datetime.now() - timedelta(seconds=self.cleanTimeout)
 		locks = self.lock_service.find_overtime_lock(query_time)
 		for lock in locks:
 			self.lock_service.delete_by_id(lock.lockId)

watchmen_collector_kernel/service/task_service.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, Optional, List
 from watchmen_auth import PrincipalService
 from watchmen_collector_kernel.model import ScheduledTask
 from watchmen_collector_kernel.model.scheduled_task import Dependence
-from watchmen_collector_kernel.storage import get_scheduled_task_service
+from watchmen_collector_kernel.storage import get_scheduled_task_service, get_scheduled_task_history_service
 from watchmen_model.common import ScheduledTaskId
 from watchmen_storage import TransactionalStorageSPI, SnowflakeGenerator
 from watchmen_utilities import ArrayHelper
@@ -26,33 +26,45 @@ class TaskService:
 		self.scheduled_task_service = get_scheduled_task_service(self.storage,
 		                                                         self.snowflake_generator,
 		                                                         self.principal_service)
+		self.scheduled_task_history_service = get_scheduled_task_history_service(self.storage,
+		                                                                         self.snowflake_generator,
+		                                                                         self.principal_service)
 
 	# noinspection PyMethodMayBeStatic
 	def consume_task(self, task: ScheduledTask, executed: Callable[[str, Dict, str], None]) -> ScheduledTask:
 		try:
 			executed(task.topicCode, task.content, task.tenantId)
-			task.isFinished = True
-			return self.scheduled_task_service.update_task(task)
+			return self.update_task_result(task)
 		except Exception as e:
 			logger.error(e, exc_info=True, stack_info=True)
 			task.isFinished = True
 			task.result = format_exc()
 			return self.scheduled_task_service.update_task(task)
 
+	def update_task_result(self, task: ScheduledTask) -> ScheduledTask:
+		self.scheduled_task_service.begin_transaction()
+		try:
+			task.isFinished = True
+			self.scheduled_task_history_service.create(task)
+			self.scheduled_task_service.delete(task.taskId)
+			self.scheduled_task_service.commit_transaction()
+			return task
+		except Exception as e:
+			raise e
+
 	def is_dependencies_finished(self, task: ScheduledTask) -> bool:
-		return ArrayHelper(task.parentTaskId).every(self.is_parent_task_finished) \
-		       and self.is_dependence_finished(task.dependOn, task.tenantId)
+		return ArrayHelper(task.parentTaskId).every(self.is_parent_task_finished) and self.is_dependence_finished(task.dependOn, task.tenantId)
 
 	def is_parent_task_finished(self, task_id: ScheduledTaskId) -> bool:
 		existed_task = self.scheduled_task_service.find_task_by_id(task_id)
-		return self.is_finished(existed_task)
+		if existed_task:
+			return self.is_finished(existed_task)
+		else:
+			return True
 
 	# noinspection PyMethodMayBeStatic
 	def is_finished(self, task: ScheduledTask) -> bool:
-		if task.status == TaskStatus.SUCCESS or task.status == TaskStatus.FAILED:
-			return True
-		else:
-			return False
+		return task.isFinished
 
 	def is_dependence_finished(self, depend_on: Optional[List[Dependence]], tenant_id: str) -> bool:
 		if ArrayHelper(depend_on).every(lambda dependence: self.is_dependent_task_finished(dependence, tenant_id)):

watchmen_collector_kernel/storage/__init__.py

@@ -1,5 +1,6 @@
 from .competitive_lock_service import get_competitive_lock_service, CompetitiveLockService
 from .scheduled_task_service import get_scheduled_task_service, ScheduledTaskService
+from .scheduled_task_history_service import get_scheduled_task_history_service, ScheduledTaskHistoryService
 
 
 from .collector_model_config_service import get_collector_model_config_service, CollectorModelConfigService
@@ -9,8 +10,11 @@ from .collector_table_config_service import get_collector_table_config_service,
 from .trigger_event_service import get_trigger_event_service, TriggerEventService
 from .trigger_model_service import get_trigger_model_service, TriggerModelService
 from .trigger_table_service import get_trigger_table_service, TriggerTableService
+
 from .change_data_record_service import get_change_data_record_service, ChangeDataRecordService
+from .change_data_record_history_service import get_change_data_record_history_service, ChangeDataRecordHistoryService
 from .change_data_json_service import get_change_data_json_service, ChangeDataJsonService
+from .change_data_json_history_service import get_change_data_json_history_service, ChangeDataJsonHistoryService
 
 
 

watchmen_collector_kernel/storage/change_data_json_history_service.py

@@ -0,0 +1,48 @@
+from watchmen_collector_kernel.storage.change_data_json_service import ChangeDataJsonShaper, ChangeDataJsonService
+
+from watchmen_auth import PrincipalService
+
+from watchmen_collector_kernel.model import ChangeDataJson
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ChangeJsonId
+from watchmen_storage import EntityName, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator
+
+
+class ChangeDataJsonHistoryShaper(ChangeDataJsonShaper):
+	pass
+
+
+CHANGE_DATA_JSON_HISTORY_TABLE = 'change_data_json_history'
+CHANGE_DATA_JSON_HISTORY_ENTITY_SHAPER = ChangeDataJsonHistoryShaper()
+
+
+class ChangeDataJsonHistoryService(ChangeDataJsonService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return CHANGE_DATA_JSON_HISTORY_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return CHANGE_DATA_JSON_HISTORY_ENTITY_SHAPER
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'change_json_id'
+
+	def get_storable_id(self, storable: ChangeDataJson) -> StorableId:
+		# noinspection PyTypeChecker
+		return storable.changeJsonId
+
+	# noinspection SpellCheckingInspection
+	def set_storable_id(self, storable: ChangeDataJson, storable_id: ChangeJsonId) -> Storable:
+		storable.changeRecordId = storable_id
+		return storable
+
+
+def get_change_data_json_history_service(storage: TransactionalStorageSPI,
+                                         snowflake_generator: SnowflakeGenerator,
+                                         principal_service: PrincipalService
+                                         ) -> ChangeDataJsonHistoryService:
+	return ChangeDataJsonHistoryService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/change_data_json_service.py

@@ -1,11 +1,11 @@
 from typing import List, Dict, Any, Optional
 
 from watchmen_auth import PrincipalService
-from watchmen_collector_kernel.common import IS_POSTED, CHANGE_JSON_ID, TENANT_ID, MODEL_TRIGGER_ID
+from watchmen_collector_kernel.common import IS_POSTED, CHANGE_JSON_ID, TENANT_ID, MODEL_TRIGGER_ID, ask_partial_size
 from watchmen_collector_kernel.model import ChangeDataJson
 from watchmen_meta.common import TupleService, TupleShaper
 from watchmen_meta.common.storage_service import StorableId
-from watchmen_model.common import Storable, ChangeJsonId
+from watchmen_model.common import Storable, ChangeJsonId, Pageable
 from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
 	ColumnNameLiteral, EntityCriteriaExpression, EntityStraightValuesFinder, EntityStraightColumn, EntitySortColumn, \
 	EntitySortMethod
@@ -106,6 +106,35 @@ class ChangeDataJsonService(TupleService):
 		finally:
 			self.close_transaction()
 
+	def find_partial_json(self, model_trigger_id: int) -> List[ChangeDataJson]:
+		self.begin_transaction()
+		try:
+			return self.storage.page(self.get_entity_pager(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_POSTED), right=False),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=MODEL_TRIGGER_ID),
+					                         right=model_trigger_id)
+				],
+				pageable=Pageable(pageNumber=1, pageSize=ask_partial_size())
+			)).data
+		finally:
+			self.close_transaction()
+
+	def is_existed(self, change_json: ChangeDataJson) -> bool:
+		self.begin_transaction()
+		try:
+			return self.storage.exists(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(
+						left=ColumnNameLiteral(
+							columnName=self.get_storable_id_column_name()
+						),
+						right=change_json.changeJsonId)
+				]
+			))
+		finally:
+			self.close_transaction()
+
 	def find_json_by_id(self, change_json_id: str) -> ChangeDataJson:
 		self.begin_transaction()
 		try:
@@ -114,7 +143,7 @@ class ChangeDataJsonService(TupleService):
 		finally:
 			self.close_transaction()
 
-	def find_id_by_resource_id(self, resource_id: str) -> Optional[ChangeDataJson]:
+	def find_by_resource_id(self, resource_id: str) -> Optional[ChangeDataJson]:
 		try:
 			self.storage.connect()
 			return self.storage.find_one(self.get_entity_finder(

watchmen_collector_kernel/storage/change_data_record_history_service.py

@@ -0,0 +1,47 @@
+from .change_data_record_service import ChangeDataRecordShaper, ChangeDataRecordService
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import ChangeDataRecordHistory
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ChangeRecordId
+from watchmen_storage import EntityName, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator
+
+
+class ChangeDataRecordHistoryShaper(ChangeDataRecordShaper):
+	pass
+
+
+CHANGE_DATA_RECORD_HISTORY_TABLE = 'change_data_record_history'
+CHANGE_DATA_RECORD_HISTORY_ENTITY_SHAPER = ChangeDataRecordHistoryShaper()
+
+
+class ChangeDataRecordHistoryService(ChangeDataRecordService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return CHANGE_DATA_RECORD_HISTORY_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return CHANGE_DATA_RECORD_HISTORY_ENTITY_SHAPER
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'change_record_id'
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id(self, storable: ChangeDataRecordHistory) -> StorableId:
+		# noinspection PyTypeChecker
+		return storable.changeRecordId
+
+	# noinspection SpellCheckingInspection
+	def set_storable_id(self, storable: ChangeDataRecordHistory, storable_id: ChangeRecordId) -> Storable:
+		storable.changeRecordId = storable_id
+		return storable
+
+
+def get_change_data_record_history_service(storage: TransactionalStorageSPI,
+                                           snowflake_generator: SnowflakeGenerator,
+                                           principal_service: PrincipalService
+                                           ) -> ChangeDataRecordService:
+	return ChangeDataRecordHistoryService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/change_data_record_service.py

@@ -1,13 +1,14 @@
 from typing import List, Optional, Dict
 
 from watchmen_auth import PrincipalService
-from watchmen_collector_kernel.common import CHANGE_RECORD_ID, TENANT_ID, IS_MERGED
+from watchmen_collector_kernel.common import CHANGE_RECORD_ID, TENANT_ID, IS_MERGED, ask_partial_size
 from watchmen_collector_kernel.model import ChangeDataRecord
 from watchmen_meta.common import TupleService, TupleShaper
 from watchmen_meta.common.storage_service import StorableId
-from watchmen_model.common import Storable, ChangeRecordId
+from watchmen_model.common import Storable, ChangeRecordId, Pageable
 from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
-	EntityCriteriaExpression, ColumnNameLiteral, EntityStraightValuesFinder, EntityStraightColumn, EntityColumnType
+	EntityCriteriaExpression, ColumnNameLiteral, EntityStraightValuesFinder, EntityStraightColumn, EntityColumnType, \
+	EntityPager
 from watchmen_utilities import ArrayHelper
 
 
@@ -110,19 +111,34 @@ class ChangeDataRecordService(TupleService):
 		finally:
 			self.close_transaction()
 
-	def count_unmerged_records(self) -> int:
+	def find_partial_records(self) -> List[ChangeDataRecord]:
 		self.begin_transaction()
 		try:
-			# noinspection PyTypeChecker
-			return self.storage.count(self.get_entity_finder(
+			return self.storage.page(self.get_entity_pager(
 				criteria=[
 					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_MERGED), right=False)
+				],
+				pageable=Pageable(pageNumber=1, pageSize=ask_partial_size())
+			)).data
+		finally:
+			self.close_transaction()
+
+	def is_existed(self, change_record: ChangeDataRecord) -> bool:
+		self.begin_transaction()
+		try:
+			return self.storage.exists(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(
+						left=ColumnNameLiteral(
+							columnName=self.get_storable_id_column_name()
+						),
+						right=change_record.changeRecordId)
 				]
 			))
 		finally:
 			self.close_transaction()
 
-	def find_change_record_by_id(self, change_record_id: ChangeRecordId) -> ChangeDataRecord:
+	def find_change_record_by_id(self, change_record_id: ChangeRecordId) -> Optional[ChangeDataRecord]:
 		self.begin_transaction()
 		try:
 			# noinspection PyTypeChecker
@@ -143,8 +159,8 @@ class ChangeDataRecordService(TupleService):
 						                         right=table_trigger_id)
 					],
 					straightColumns=[EntityStraightColumn(columnName='data_id', columnType=EntityColumnType.JSON)]
-					)
 				)
+			)
 			return ArrayHelper(result).map(lambda x: x.get('data_id')).to_list()
 		finally:
 			self.close_transaction()

watchmen_collector_kernel/storage/scheduled_task_history_service.py

@@ -0,0 +1,45 @@
+from .scheduled_task_service import ScheduledTaskShaper, ScheduledTaskService
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import ScheduledTask
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ScheduledTaskId
+from watchmen_storage import EntityName, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator
+
+
+class ScheduledTaskHistoryShaper(ScheduledTaskShaper):
+	pass
+
+
+SCHEDULED_TASK_HISTORY_TABLE = 'scheduled_task_history'
+SCHEDULED_TASK_HISTORY_ENTITY_SHAPER = ScheduledTaskHistoryShaper()
+
+
+class ScheduledTaskHistoryService(ScheduledTaskService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return SCHEDULED_TASK_HISTORY_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return SCHEDULED_TASK_HISTORY_ENTITY_SHAPER
+
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'task_id'
+
+	def get_storable_id(self, storable: ScheduledTask) -> StorableId:
+		return storable.taskId
+
+	def set_storable_id(
+			self, storable: ScheduledTask, storable_id: ScheduledTaskId) -> Storable:
+		storable.taskId = storable_id
+		return storable
+
+
+def get_scheduled_task_history_service(storage: TransactionalStorageSPI,
+                                       snowflake_generator: SnowflakeGenerator,
+                                       principal_service: PrincipalService
+                                       ) -> ScheduledTaskHistoryService:
+	return ScheduledTaskHistoryService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/scheduled_task_service.py

@@ -1,17 +1,35 @@
 from typing import Optional, List, Any, Dict
 
+from watchmen_collector_kernel.common import ask_partial_size
+from watchmen_utilities import ArrayHelper
+
+from watchmen_collector_kernel.model.scheduled_task import Dependence
+
 from watchmen_auth import PrincipalService
 from watchmen_collector_kernel.model import ScheduledTask
 from watchmen_meta.common import TupleService, TupleShaper
 from watchmen_meta.common.storage_service import StorableId
-from watchmen_model.common import Storable, ScheduledTaskId
+from watchmen_model.common import Storable, ScheduledTaskId, Pageable
 from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, \
 	EntityCriteriaExpression, ColumnNameLiteral, SnowflakeGenerator, EntitySortColumn, EntitySortMethod, \
-	EntityCriteriaJoint, EntityCriteriaJointConjunction, EntityStraightValuesFinder, EntityStraightColumn, \
-	EntityCriteriaOperator
+	EntityCriteriaJoint, EntityStraightValuesFinder, EntityStraightColumn
 
 
 class ScheduledTaskShaper(EntityShaper):
+
+	@staticmethod
+	def serialize_dependence(dependence: Dependence) -> dict:
+		if isinstance(dependence, dict):
+			return dependence
+		else:
+			return dependence.dict()
+
+	@staticmethod
+	def serialize_depend_on(depend_on: Optional[List[Dependence]]) -> Optional[list]:
+		if depend_on is None:
+			return None
+		return ArrayHelper(depend_on).map(lambda x: ScheduledTaskShaper.serialize_dependence(x)).to_list()
+
 	def serialize(self, entity: ScheduledTask) -> EntityRow:
 		return TupleShaper.serialize_tenant_based(entity, {
 			'task_id': entity.taskId,
@@ -20,7 +38,7 @@ class ScheduledTaskShaper(EntityShaper):
 			'content': entity.content,
 			'model_name': entity.modelName,
 			'object_id': entity.objectId,
-			'depend_on': entity.dependOn,
+			'depend_on': ScheduledTaskShaper.serialize_depend_on(entity.dependOn),
 			'parent_task_id': entity.parentTaskId,
 			'tenant_id': entity.tenantId,
 			'is_finished': entity.isFinished,
@@ -118,13 +136,43 @@ class ScheduledTaskService(TupleService):
 		finally:
 			self.close_transaction()
 
+	def find_partial_tasks(self) -> List[ScheduledTask]:
+		self.begin_transaction()
+		try:
+			return self.storage.page(self.get_entity_pager(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='is_finished'), right=False)
+				],
+				pageable=Pageable(pageNumber=1, pageSize=ask_partial_size())
+			)).data
+		finally:
+			self.close_transaction()
+
+	def is_existed(self, task: ScheduledTask) -> bool:
+		self.begin_transaction()
+		try:
+			return self.storage.exists(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(
+						left=ColumnNameLiteral(
+							columnName=self.get_storable_id_column_name()
+						),
+						right=task.taskId)
+				]
+			))
+		finally:
+			self.close_transaction()
+
 	def find_by_resource_id(self, resource_id: str) -> List[Dict[str, Any]]:
 		self.begin_transaction()
 		try:
 			return self.storage.find_straight_values(EntityStraightValuesFinder(
 				name=self.get_entity_name(),
-				criteria=[EntityCriteriaExpression(left=ColumnNameLiteral(columnName='resource_id'), right=resource_id)],
-				straightColumns=['task_id', 'resource_id', 'tenant_id']
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='resource_id'), right=resource_id)],
+				straightColumns=[EntityStraightColumn(columnName='task_id'),
+				                 EntityStraightColumn(columnName='resource_id'),
+				                 EntityStraightColumn(columnName='tenant_id')]
 			))
 		finally:
 			self.close_transaction()
@@ -148,6 +196,7 @@ class ScheduledTaskService(TupleService):
 		finally:
 			self.close_transaction()
 
+
 def get_scheduled_task_service(storage: TransactionalStorageSPI,
                                snowflake_generator: SnowflakeGenerator,
                                principal_service: PrincipalService

watchmen_collector_kernel-16.4.10.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: watchmen-collector-kernel
+Version: 16.4.10
+Summary: 
+License: MIT
+Author: botlikes
+Author-email: 75356972+botlikes456@users.noreply.github.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Provides-Extra: mongodb
+Provides-Extra: mssql
+Provides-Extra: mysql
+Provides-Extra: oracle
+Provides-Extra: oss
+Provides-Extra: postgresql
+Provides-Extra: s3
+Requires-Dist: numpy (>=1.23.3,<2.0.0)
+Requires-Dist: watchmen-data-kernel (==16.4.10)
+Requires-Dist: watchmen-storage-mongodb (==16.4.10) ; extra == "mongodb"
+Requires-Dist: watchmen-storage-mssql (==16.4.10) ; extra == "mssql"
+Requires-Dist: watchmen-storage-mysql (==16.4.10) ; extra == "mysql"
+Requires-Dist: watchmen-storage-oracle (==16.4.10) ; extra == "oracle"
+Requires-Dist: watchmen-storage-oss (==16.4.10) ; extra == "oss"
+Requires-Dist: watchmen-storage-postgresql (==16.4.10) ; extra == "postgresql"
+Requires-Dist: watchmen-storage-s3 (==16.4.10) ; extra == "s3"

{watchmen_collector_kernel-16.4.9.dist-info → watchmen_collector_kernel-16.4.10.dist-info}/RECORD

@@ -1,14 +1,18 @@
 watchmen_collector_kernel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-watchmen_collector_kernel/common/__init__.py,sha256=QJHylPJAMoSbSa6EfgiQTLNtkQKSCUJucf7ZG3Nqswg,175
+watchmen_collector_kernel/common/__init__.py,sha256=xDuOxA-p9hVm0IzAsPlrnsohNJgZ0qF6g8Kx8bn1p-E,263
 watchmen_collector_kernel/common/constants.py,sha256=mIsGBhAjHbmeuVeNYDOKLhiBqG2sSX-0vs8ipEEIo9E,302
-watchmen_collector_kernel/model/__init__.py,sha256=PfA3bsFeAXTTQRSZMyzdm9Oe6dSqDR-y5vfQBlgAdSE,542
+watchmen_collector_kernel/common/settings.py,sha256=xOOrpMe2E8MNek2Z4CLFTQp_yw2NOJCVi_Y28kgukOc,697
+watchmen_collector_kernel/model/__init__.py,sha256=HyMAWNLN1ZIppJtLbqVIIgyFEqrQZshNZk5It5fqKbY,666
 watchmen_collector_kernel/model/change_data_json.py,sha256=-oNIGsvYo8KJJsSFusbGa9kIuFfE0otLnWe-zz9O42A,495
+watchmen_collector_kernel/model/change_data_json_history.py,sha256=L9ACRe5tCP5Pc5MrpAVkLHe-6EfgZsUBfnQ2BXIYu4M,99
 watchmen_collector_kernel/model/change_data_record.py,sha256=vadzugcX4nl6G3F-jt7DtuVqjE8vtlasu86DDjpaGGM,330
+watchmen_collector_kernel/model/change_data_record_history.py,sha256=87XLw51oT8TXDRbQLWKy4U1Tyn3KtM22G5wPlMSYCv8,106
 watchmen_collector_kernel/model/collector_model_config.py,sha256=oE0T9I_9uGppttoytvzl7-35WgwlWu7s6awNtsK4Q20,288
 watchmen_collector_kernel/model/collector_table_config.py,sha256=R80d2rqfVRj_rZ6-mognaLYe26R7r3g4nFR3Wj-4YLY,2143
 watchmen_collector_kernel/model/competitive_lock.py,sha256=fxDRuzZpsgrZjGeuADS3zRYqQioqWhg72Pr592U_Yvw,264
 watchmen_collector_kernel/model/condition.py,sha256=jGsjvb5z9XRFW0B55k-iC2_Zle4rl-A5J_6PB6EV6mA,1942
-watchmen_collector_kernel/model/scheduled_task.py,sha256=tPk4CmBvL0E61jk-6TYJHD2Ch4k-NdF9tMBi8WPMWc4,674
+watchmen_collector_kernel/model/scheduled_task.py,sha256=-HBwZVbCkuZaTedixeH0s3z-d09nXSlERzQBPfNGfsY,1362
+watchmen_collector_kernel/model/scheduled_task_history.py,sha256=0lgWIQWN2r_HcMoLGwKxzLmaxGNtr0NZF7NaT_DeOyE,93
 watchmen_collector_kernel/model/trigger_event.py,sha256=ZjVgWQS_qqILchw4fGFzxn1tJUMx77s2_UpyiBd7azA,251
 watchmen_collector_kernel/model/trigger_model.py,sha256=NpnIbdax8vQeGYeGcOMpWpjYUhkeZUil--6-yTNpv3k,175
 watchmen_collector_kernel/model/trigger_table.py,sha256=aPYJlIb-8aX_-O6vZQp3DU58zYtyosYLGFjpL81ijds,229
@@ -17,22 +21,25 @@ watchmen_collector_kernel/service/criteria_builder.py,sha256=NAk0yQBn4KARttqEOwW
 watchmen_collector_kernel/service/data_capture.py,sha256=45asoQQlv016NKsPoiUVgaSCOJzUBHDCmWr7XPt-8VI,2873
 watchmen_collector_kernel/service/extract_source.py,sha256=MYldG4gR6t-2JeVJ6nL5aAb59AjxkQWj3dVwzJKXN9Q,2928
 watchmen_collector_kernel/service/extract_utils.py,sha256=PIyxFG7U37ZXLYlOdIK-Dh-kBptXPFqk-9-b1LuPL1A,2452
-watchmen_collector_kernel/service/lock_clean.py,sha256=qeNc8vZtfxXTNpGhGc_ZnUD9iRGK2VXNEpv1VglVWCA,965
+watchmen_collector_kernel/service/lock_clean.py,sha256=-TVsJjr61MtgBU67S9hBrcH4Mb7xFEG61njq9GA5obY,1142
 watchmen_collector_kernel/service/lock_helper.py,sha256=GxqjIsCD-jn5kDICVWS1LlTFCuMpnRSpcrQtPLv5bxs,842
 watchmen_collector_kernel/service/task_housekeeping.py,sha256=i1lnZ4jo-RLjLQD0Z7HSLQqjXuSqdL3zqHDfFVaNbe8,1673
-watchmen_collector_kernel/service/task_service.py,sha256=thA_PRNrWvx_g8tuwMbUUqrXBYgnYcBozoNohA4jqTI,3050
+watchmen_collector_kernel/service/task_service.py,sha256=FjiJgb4C5YZRYj7iwrZfrLbfWSN3jvPJkaX9ISA9IYg,3634
 watchmen_collector_kernel/service/trigger_collector.py,sha256=IP_ILJNMhahBogtvfS1iHDOJAxKCDBDJFXTDi98R11M,6790
-watchmen_collector_kernel/storage/__init__.py,sha256=sstizR2fcwo4ZhqfiqceTxxS49HTtfExCPMeEaYc9bc,832
-watchmen_collector_kernel/storage/change_data_json_service.py,sha256=YwbHDff0W_ydfOJRXB8W_J4iE4VIj0XEwRrXd0KUWCg,7536
-watchmen_collector_kernel/storage/change_data_record_service.py,sha256=MOju5vTl-ZQrpEfL7DytvB_T_JM0dYyXGAzrhNnzb2Y,7463
+watchmen_collector_kernel/storage/__init__.py,sha256=9jj793SaeAJ637JisLMXDnp_59Zs20Q4hldYzBkdgjA,1173
+watchmen_collector_kernel/storage/change_data_json_history_service.py,sha256=8WPdazvG6EPTOtmiAXtb1yAMRwUaBmD-C6S0ZwsCMrw,1774
+watchmen_collector_kernel/storage/change_data_json_service.py,sha256=v_NslDdCRgKjCqIOgcQwD7hA-Ea14NOB4Zkr_g3zqBo,8464
+watchmen_collector_kernel/storage/change_data_record_history_service.py,sha256=q_41H2AQGLf_XD2W6ZsATLWvxpdK50swOWt5IMCTWjg,1845
+watchmen_collector_kernel/storage/change_data_record_service.py,sha256=QUwqn-lTIf0dYWfEKEJXy16nY-Iz6NLnihWYWP1BoQ4,7953
 watchmen_collector_kernel/storage/collector_model_config_service.py,sha256=kWLjmppPpRuN0VptiAEGA38BJ20fFD5Q5gxPZJRbQYs,3830
 watchmen_collector_kernel/storage/collector_table_config_service.py,sha256=aVZeN5AhzUORHaZQUDo_MlKcX6AkgcHcQeI6UwAoAT0,5659
 watchmen_collector_kernel/storage/competitive_lock_service.py,sha256=jjxxHb4Dr0DIDX_g26wtCa8vGLGLnc4BJQGl0d3J31M,2534
-watchmen_collector_kernel/storage/scheduled_task_service.py,sha256=sZLwF8zKOArh8QuchkDPcip7B-kTyVBhHM73nxU89Tg,5376
+watchmen_collector_kernel/storage/scheduled_task_history_service.py,sha256=f-JXZ5G87oy7FdYPkbbfTKhI_oRm4wauWNvTw9hxGjM,1586
+watchmen_collector_kernel/storage/scheduled_task_service.py,sha256=gMv3jxAYJg_sqV4pD5WmV4LXF9Wz8-41DnbkEgwoW8o,6825
 watchmen_collector_kernel/storage/trigger_event_service.py,sha256=DKSCQ0sYSH3uAtGmokvncD9FIYvjoVsk7QtqdRMQGhM,3099
 watchmen_collector_kernel/storage/trigger_model_service.py,sha256=0-_YcL5FNGHy2MKn8vTYrWFaYOPW_u4iKQRG00AOfCI,3219
 watchmen_collector_kernel/storage/trigger_table_service.py,sha256=RHiFJaT3UQmCpz-gxnfsoBPV7lS8JM1i9DCQn3BnfA4,3779
-watchmen_collector_kernel-16.4.9.dist-info/LICENSE,sha256=iuuG7ErblOdcEZi5u89VXS0VIUiTb4flerGp_PAS9E4,1061
-watchmen_collector_kernel-16.4.9.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-watchmen_collector_kernel-16.4.9.dist-info/METADATA,sha256=Nr3F6yWxRJrnpIyEMYfecoJA9zGY8-5mH6Oeh5uyBXY,1135
-watchmen_collector_kernel-16.4.9.dist-info/RECORD,,
+watchmen_collector_kernel-16.4.10.dist-info/LICENSE,sha256=iuuG7ErblOdcEZi5u89VXS0VIUiTb4flerGp_PAS9E4,1061
+watchmen_collector_kernel-16.4.10.dist-info/METADATA,sha256=yLbeak57oLrnO0d2HISTNI4owY5NERCM6UsrvFz9yn0,1183
+watchmen_collector_kernel-16.4.10.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+watchmen_collector_kernel-16.4.10.dist-info/RECORD,,

{watchmen_collector_kernel-16.4.9.dist-info → watchmen_collector_kernel-16.4.10.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.4.0
+Generator: poetry-core 1.5.2
 Root-Is-Purelib: true
 Tag: py3-none-any

watchmen_collector_kernel-16.4.9.dist-info/METADATA

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: watchmen-collector-kernel
-Version: 16.4.9
-Summary: 
-License: MIT
-Author: botlikes
-Author-email: 75356972+botlikes456@users.noreply.github.com
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Provides-Extra: mongodb
-Provides-Extra: mssql
-Provides-Extra: mysql
-Provides-Extra: oracle
-Provides-Extra: oss
-Provides-Extra: postgresql
-Provides-Extra: s3
-Requires-Dist: watchmen-data-kernel (==16.4.9)
-Requires-Dist: watchmen-storage-mongodb (==16.4.9) ; extra == "mongodb"
-Requires-Dist: watchmen-storage-mssql (==16.4.9) ; extra == "mssql"
-Requires-Dist: watchmen-storage-mysql (==16.4.9) ; extra == "mysql"
-Requires-Dist: watchmen-storage-oracle (==16.4.9) ; extra == "oracle"
-Requires-Dist: watchmen-storage-oss (==16.4.9) ; extra == "oss"
-Requires-Dist: watchmen-storage-postgresql (==16.4.9) ; extra == "postgresql"
-Requires-Dist: watchmen-storage-s3 (==16.4.9) ; extra == "s3"