Access control methods for private code repositories based on permission versions
By binding access contexts to state versions and performing authoritative verification at the final send and output locations, the problem of authorization reuse across contexts and permission changes in private code repository access control is solved, achieving accuracy and consistency in access control.
Patent Information
- Application Number
- CN202611585499.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-10-14
- Publication Date
- 2026-11-17
AI Technical Summary
In existing technologies, private code repository access control methods suffer from problems such as inaccurate permission judgments and inconsistent output results due to the reuse of authorization across contexts and the continued availability of old credentials and associated results after changes in permissions and mappings.
By binding the access context to the state version, and placing the verification and final send and output locations within the same execution protection, the consistency of permission versions is ensured, preventing requests or results from being sent or output based on old dependencies after a change has been successfully committed.
It restricts cross-context reuse, prevents continued access based on old dependencies after permission changes, ensures the accuracy and consistency of access control, and avoids mixed use of authorization judgments and errors in result output.
Smart Images

Figure CN123123019A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of computer network access control, and more particularly to a method for access control of private code repositories based on permission versions. Background Technology
[0002] Unified access services for multi-platform private code repositories typically involve setting up a server-side proxy between the user and the code hosting platform. The server manages project membership, role permissions, login sessions, and the mapping from logical repositories to the platform's actual repositories. To reduce redundant authorization checks, the access service can use access credentials and authorization caching, and perform repository-related domain information lookups as a derived task. Therefore, the proxy service needs to simultaneously control code repository access and the data output derived from repository information.
[0003] When access credentials or authorization caches do not fully differentiate between projects, activity roles, platform instances, logical repositories, and operations, existing authorization decisions may be reused by another access context. After member privilege revocation, role switching, session expiration, or repository mapping changes, if the expiration is only expressed by asynchronously deleting credentials and cache records, the original authorization may still be used until the deletion is complete; already generated related query tasks and results may also continue to retain access privileges, forming an output path detached from the original repository permissions.
[0004] Authorization is only verified at the start of request processing, and authorization changes may occur between successful verification and actual delivery. Furthermore, for asynchronous returns, cache hits, pagination, or exports, authorization checks during result generation cannot directly replace those during output. Therefore, it is necessary to associate authority status verification with the final delivery and result output, and to clearly define the order of these operations with authorization and mapping changes.
[0005] Therefore, there is a need for a permission-based private code repository access control method that can address the shortcomings of the existing technologies. Summary of the Invention
[0006] One objective of this invention is to propose a private code repository access control method based on permission versions. Addressing the issues of cross-context reuse of authorizations and the continued availability of old credentials and associated results after permission and mapping changes in existing technologies, this invention proposes a technical solution that binds access contexts and state version dependencies together, and places authoritative verification and actual delivery within the same execution protection at the final send and output locations. Changes to member authorization, role policies, session states, and repository mappings are atomically committed with version increments, forming a mutually exclusive order with send and output involving the same state; derived domain name queries are independently authenticated, and task envelopes and isolated storage results inherit the original dependencies. This invention effectively restricts cross-context reuse and prevents the sending of new requests or output of results based on old dependencies after a successful change commit.
[0007] This invention provides a method for access control of private code repositories based on permission versions, comprising: S1, constructing an access context from a verified session that includes users, projects, activity roles, platform instances, logical repositories, and operations; S2, reading member authorizations, role policies, session states, and repository mappings from a consistent snapshot according to the access context, generating dependency records containing each state identifier and monotonically increasing versions, and binding access credentials and authorization cache together with the access context and dependency records after authorization is approved; S3, verifying the access request, access credentials, and access context of the matched authorization cache, and placing the dependency records, authority state verification, and request sending in the same execution context at the final sending location. Within the protection, after verification, the server parses the real repository according to the repository mapping and proxies the request to obtain the execution result; S4, bind the execution result to the access context and original dependency record that produced the result, and place the access context verification between the result reading request and the execution result, the original dependency record and authority status verification, and the result output in the same execution protection at the result output position, and output only after the verification and validation are both passed; S5, atomically commit the changes of member authorization, role policy, session state or repository mapping with the corresponding version increment, and make the change commit mutually exclusive with the execution protection involving the same status identifier, and reject the request sending and result output corresponding to the old dependency record after successful commit.
[0008] Optionally, S1 includes: determining the user identifier and session identifier based on the verified session, and determining the item identifier and activity role identifier based on the confirmed items and activity roles in the session;
[0009] Verify the platform instance, logical repository, and operation execution attribution specified in the access request, and generate an access context;
[0010] Session identifiers are used as the basis for locating session states. Combinations of user identifiers, project identifiers, activity role identifiers, platform instance identifiers, logical repository identifiers, and operation identifiers are used as matching items for access contexts. Access credentials or authorization caches are not reused between access contexts with different matching items.
[0011] Optionally, S2 includes: reading the state content and version of member authorization, role policy, session state, and repository mapping that are effective for the access context from the server-side state store that stores the authority state, using the same snapshot;
[0012] Each state is uniquely identified on the server as a state identifier, and the state identifier is paired with the version to form a dependency record;
[0013] If the session is valid, the user is a project member, the activity role allows the operation, and the repository mapping is valid, an authorization decision is made to allow access.
[0014] The server stores the binding relationship between access credentials, access context, and dependency records that cannot be modified by the client. The authorization cache stores the same binding relationship and authorization determination. The cache index contains access context and dependency records.
[0015] Optionally, S3 includes: reconstructing the access context based on the verified session associated with the access request, comparing it item by item with the access context bound to the access credentials, and comparing the access context bound to the authorization cache and the dependency record when there is an authorization cache hit;
[0016] The authoritative state is read using the state identifier in the dependency record. Each version is verified to be equal and the corresponding state still allows operation. The version in the authorization cache is not used to replace the version in the authoritative state.
[0017] If any comparison or verification fails, the request will be rejected. If the verification passes, only the repository mapping corresponding to the dependency record will be used. On the server side, the logical repository will be resolved into the real repository within the platform instance, and the proxy sending will be completed using the platform access credentials stored on the server side.
[0018] Furthermore, for domain information queries originating from the logical repository, in addition to repository access authorization, authorization determination is made independently for query operations and output fields based on role policies;
[0019] After the authorization is approved, a task envelope is generated and saved on the server. The task envelope is bound to the source logical repository, access context, original dependency record, approved domain name range of repository mapping, query parameters and approved output fields. The original dependency record is taken from the dependency record used for repository access authorization when the task envelope is generated.
[0020] The scope of the approved domain names bound to the task envelope is used as the boundary of the query target, which constrains the query target to be within the scope of the approved domain names. The task execution node verifies the original dependency records and query authorization at the final query request sending position, and sends the query request according to execution protection. If the verification fails, the request is rejected.
[0021] Optionally, S4 includes: saving the execution result together with the access context and dependency record used when the request was sent, and using the dependency record used when the request was sent as the original dependency record;
[0022] For the result read request, reconstruct the access context, check it against the access context bound to the execution result, and read the authoritative status with the status identifier in the original dependency record to verify that each version is equal and the corresponding status still allows operation;
[0023] Include access context verification, original dependency record verification, and delivery of execution results to the requester within the same execution protection at the result output location; refuse delivery if verification fails.
[0024] Furthermore, after the domain name intelligence query is completed, the results are first written to a server isolation area that is not open to the requester, and then saved in association with the task envelope and the original dependency record.
[0025] For reading execution results, result cache hits, pagination, and export, the binding relationship between the requester's access context and the task envelope is verified respectively. The original dependency records and output field authorizations are re-verified within the execution protection at the result output position. After the verification is passed, only the results corresponding to the authorized output fields in the task envelope are released.
[0026] The index of the result cache includes the source logical repository, access context, original dependency record, approved domain range, query parameters and approved output fields. It is prohibited to replace the original dependency record of the existing execution result or result cache with the updated dependency record.
[0027] Furthermore, each actual request delivered to the remote platform is defined as a sending unit, and each actual result data block delivered to the requester is defined as an output unit.
[0028] The sending unit and the output unit are delivered only after obtaining execution protection and completing the verification of the original dependency records. Each page after pagination and each data block exported by block are respectively used as output units.
[0029] When the original dependency record becomes invalid, the sending and output units that have not yet been delivered are stopped. The subsequent return results of the sent queries are still written to the server isolation area and the original dependency record is maintained. When reauthorization is performed, the task envelope is regenerated and the query is re-executed.
[0030] Optionally, S5 includes: for events such as revoking member authorization, modifying role policies, switching the active role of a session, invalidating a session, and changing repository mappings, updating the corresponding authority status and incrementing the corresponding version, and committing the updated status content and version in the same transaction;
[0031] When the state is restored to the previous content, the version is still incremented. When the state is deleted, the state identifier, the incremented version, and the expiration mark are retained. It is forbidden to pair the used state identifier with the version and reassign it to a valid state.
[0032] A success message is returned only after the atomic commit is completed. Authorization is determined based on authority status and version. Asynchronous deletion of old access credentials, authorization cache, and execution results only reclaims storage records.
[0033] Furthermore, read-write locks are set for all state identifiers in the dependency record, coordinated by the server.
[0034] After acquiring the corresponding read lock, the authoritative status of the request to send and the result output are verified. The read lock is held until the actual sending or actual output is completed, or until it is determined to give up sending or output, and then the read lock is released.
[0035] After acquiring the corresponding write lock, the authoritative state is updated, the version is incremented, and an atomic commit is performed. After the commit is completed, the write lock is released.
[0036] Each server execution node performs the aforementioned operations through the same lock coordination entry point, acquiring multiple locks in a unified order of status identifiers. If an exception occurs where the required lock cannot be acquired or the authoritative status cannot be read, the request sending and result output will not be executed.
[0037] The beneficial effects of this invention are:
[0038] 1. By forming an access context from a verified session, the authorization state and repository mapping are read in a consistent snapshot, and the access credentials are bound together with the authorization cache and the context and dependency records. This ensures that cache hits cannot replace authoritative state verification and avoids the use of mismatched authorization judgments due to mixed project, role, or repository scopes.
[0039] 2. By placing the final request sending and result output separately within the same execution protection as the access context verification and dependency verification, and by making state changes and version increment atomic commits mutually exclusive with execution protection, the order between change effectiveness and delivery is clearly defined, preventing the addition of new sending units or output units based on old dependencies after a change is successfully committed; asynchronous deletion only undertakes storage reclamation and does not determine the time when permissions expire.
[0040] 3. By independently authenticating domain information queries, the source repository, original dependencies, approved domain range, query parameters, and approved output fields are bound to the task envelope. The results are first isolated and saved. During reading, cache hits, pagination, and export, the original dependencies are re-verified to limit the query and output range and prevent old results from regaining output eligibility by replacing version tags. Attached Figure Description
[0041] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:
[0042] Figure 1 This is a flowchart illustrating the overall process of the private code repository access control method based on permission versions according to the present invention.
[0043] Figure 2 This is a flowchart of permission change, version increment atomic commit, and execution protection mutual exclusion in S5 of the present invention. Detailed Implementation
[0044] The present invention will now be described in further detail with reference to the accompanying drawings. These drawings are simplified schematic diagrams, illustrating only the basic structure of the invention, and therefore only show the components relevant to the invention.
[0045] refer to Figures 1-2 The access control method for private code repositories based on permission versions includes: S1. Constructing an access context from a verified session, containing users, projects, activity roles, platform instances, logical repositories, and operations; S2. Reading member authorizations, role policies, session states, and repository mappings from a consistent snapshot according to the access context, generating dependency records containing each state identifier and monotonically increasing versions, and binding access credentials and authorization cache together with the access context and dependency records after authorization is approved; S3. Verifying the access request, access credentials, and access context of the matched authorization cache, and placing the dependency records, authority state verification, and request sending within the same execution protection at the final sending location. After verification, the server parses the real repository according to the repository mapping and proxies the request to obtain the execution result; S4, bind the execution result to the access context and original dependency record that produced the result, and place the access context verification between the result reading request and the execution result, the original dependency record and the authority status verification and the result output in the same execution protection at the result output position, and output only after the verification and validation are both passed; S5, atomically commit the changes of member authorization, role policy, session state or repository mapping with the corresponding version increment, and make the change commit mutually exclusive with the execution protection involving the same status identifier. After successful commit, reject the request sending and result output corresponding to the old dependency record.
[0046] In this specific embodiment, S1 includes:
[0047] In this specific implementation, the private code repository access service receives the user's repository request. The server sets up a session entry point, an authorization processor, a task execution node, a unified delivery coordinator, and an authoritative state store. The task execution node is responsible for preparing the request and processing the return result. The unified delivery coordinator is responsible for actually sending the request to the remote platform, outputting the result to the requester, and coordinating permission changes. The three links use the same set of state identifiers to locate read-write locks. The authoritative state store adopts a relational database that supports multi-version consistency snapshots and transaction commits. The client does not hold remote platform access credentials.
[0048] The session entry point reads the user identifier, session identifier, confirmed project identifier, and active role identifier from the authenticated server session record. The session record also stores the validity flag, session expiration time, and status version. The user, project, or role text submitted by the client does not directly overwrite these fields. In this specific implementation, user A, project A, audit role, platform A, and logic repository A are selected to be used throughout the subsequent processing. When the same user logs in in other sessions, different session identifiers are obtained to prevent the session logout status from being used by another session.
[0049] The access request carries the platform instance identifier, logical repository identifier, operation identifier and request parameters. The session entry point converts the platform alias and repository alias into a fixed identifier assigned by the server. The alias is only used for location and does not participate in authorization reuse. The fixed identifier uses an identifier value that cannot be reassigned. The operation identifier is read from the server interface registration record. Reading repository content, submitting repository content and reading the domain name information derived from the repository correspond to clear business semantics. Unknown operations, duplicate conflicting parameters or aliases that cannot be uniquely resolved will all return a rejection record.
[0050] The server reads the association records between the confirmed project and the platform using the confirmed project as the search criteria. Then, it uses the project identifier, platform instance identifier, and logical repository identifier to find the repository ownership. It requires that the platform is registered with the project, the logical repository belongs to the platform instance, and the request interface supports the specified operation. The ownership verification only determines whether the object pointed to by the request is legal and does not replace the S2 member authorization and role policy judgment. The variable platform relationship involved in the ownership judgment is managed together with the repository mapping status and the mapping version is incremented to prevent ownership changes from bypassing subsequent dependency verification.
[0051] The session entry writes the user, project, activity role, platform instance, logical repository, and operation into the access context in a fixed field order. Each field is encoded with type, length, and actual value. The matching algorithm compares the standard identifiers one by one in the field order without comparing the client-displayed name. If any field is different, it is considered a different access context. The session identifier is saved separately as the basis for session state positioning and is bound to the current request and subsequent credentials. Consistent session positioning is an additional constraint implemented in this implementation method. If the six matching items are the same but the session identifier is different, the credentials of that session are not allowed to be reused.
[0052] The server sets fixed field types and value ranges for context records. All six matching items are dimensionless identifiers. Permissions are not inferred by performing arithmetic operations on the identifiers. The attribution index uses a composite key composed of project, platform instance, and logical repository. If the composite key does not match a unique valid attribution record, the construction of an authoritative context is refused. If a request is made to use an obsolete alias, it will not redirect to another repository with a similar name.
[0053] For subsequent result reading, pagination, or export interfaces, the server obtains the original business operation corresponding to the interface from the interface registration record. The business operation still uses the read repository content or the domain name information derived from the read repository when the result is generated. Reading, pagination, and export are delivery method fields and are subject to corresponding output permission constraints. The original operation passed in by the client is not taken as trusted input. The server first reconstructs the context according to the verified session and the requested resources, and then compares it with the context where the result is saved, avoiding directly copying the identity field in the result in order to pass the comparison.
[0054] In this specific implementation, the request to read the content of logical repository A forms a matching combination of user A, project A, audit role, platform A, logical repository A and read repository content. If the same user changes to submit repository content, the operation matching item changes and authorization is re-requested. If the session switches active roles, S5 first updates the session status and version, and then constructs the context with the new role. The role and session version in the old voucher remain unchanged.
[0055] The access service writes the constructed access context, session location information, standard request parameters and request identifier into the server-side request work record. The identity field in the work record can only be written by the server-side component. S2 uses this record as input to read the authority status and generate authorization dependencies. Requests that fail to be attributed or whose sessions cannot be verified only leave the failure reason and request identifier and do not enter the credential issuance process.
[0056] In this specific embodiment, S2 includes:
[0057] The authorization processor reads the authorization basis from the server-side state storage that stores the authoritative state. Using the request work record of S1 as the search input, it searches for member authorization status by user and project, role policy status by project and activity role, session status by session identifier, and repository mapping status by project, platform instance, and logical repository. Each of the four types of status stores a unique status identifier, version, validity mark, and status content. Member authorization content includes member qualifications and assigned roles. Role policy content includes approved repository operations, domain name query operations, output methods, and output fields. Repository mapping content includes the project, platform instance, logical repository, real repository identifier, and approved domain name range.
[0058] These states are established by the server-side management interface based on member management, role configuration, login and role switching, and repository access configuration. A unique state identifier is generated during creation, and the version is set to a positive integer one. The version is stored as a dimensionless integer and is not replaced by a timestamp. The valid values of the state content are constrained by the corresponding field type. The permission field adopts an explicitly listed set of operations and fields. An empty authorization set indicates that it is not allowed. Missing states are not processed as allowed by default. Subsequent updates all go through the S5 change entry.
[0059] In this specific implementation, a member authorization status record indicates that user A belongs to project A and has been assigned an audit role, version 12; a role policy status record indicates that the audit role is allowed to read repository content, query domain information, and read and paginate output domain name and resolution address fields, version 7; a session status record indicates that the current user, project, and activity role are consistent with and valid in S1, version 3; and a repository mapping status record indicates that logical repository A is mapped to the real repository 101 of platform A, version 9. The business identifiers in the above records are all server-side lookup keys.
[0060] The authorized processor completes the location, content reading, and version reading of the four types of states in the same read-only snapshot transaction, so that the four types of records correspond to the same committed view. During the reading process, no independent cache is used to fill in one type of record. If there is a missing item, multiple valid mappings, or reading failure, the authorization is terminated. If the state changes after the snapshot is created, the dependencies generated by the snapshot are allowed to be saved, but the dependencies still need to be verified by the current authoritative state before the actual S3 delivery. The snapshot itself does not constitute subsequent delivery permission.
[0061] The processor sequentially verifies that the session is valid and has not expired, that the session user, confirmed project, and activity role are consistent with the request, that the user has project membership and has been assigned the activity role, that the role policy allows the request operation, and that the repository mapping is valid and belongs to the same entity. Only when all conditions are met will an authorization decision for allowing access be written. If any condition is not met, a reason for denial will be written and no access credential will be issued. The session expiration time is verified according to the coordinator's server time in milliseconds. Once the session expires, new sending or output units will be rejected.
[0062] For each state that actually participates in the above judgment, its unique state identifier is matched with the current snapshot version to form a dependency. The dependencies are arranged in byte order of the state identifier and deduplicated to form an immutable dependency record. If the same identifier appears in different versions, it is considered a read error and the authorization is terminated. This implementation uses four dependencies and allows the record to carry the snapshot transaction identifier for tracking. However, the final verification still uses the state identifier and version item by item. The snapshot number cannot replace the state version.
[0063] The server generates an unpredictable random credential identifier and writes it, along with the complete access context, session identifier, dependency record, authorization determination, and credential expiration time, into the credential table. The client only obtains the credential identifier, which does not contain the real repository address or platform access credentials. The dependency version, allow flag, or role modification value submitted by the client does not overwrite the credential table. The validity period of the access credential is set to five minutes and does not exceed the remaining validity period of the session. The expiration limit only determines whether to accept the credential and cannot replace authoritative state verification.
[0064] The authorization cache stores the same access context, session location information, dependency records, and authorization determination as the credential table. Its index requires the access context and complete dependency records to be coded in a standardized manner, and then adds the session identifier. The cache locates candidates by summarizing these fields. After a hit, it still checks the complete fields byte by byte to exclude summary collisions or incorrect indexes. The dependencies carried by the current credential participate in the cache lookup. When the cache misses, it reads the credential binding record on the server to continue verification, instead of replacing the old credential dependency based on the latest cache found in the context.
[0065] For domain name intelligence queries originating from logical repositories, the authorization processor first completes the access authorization for the corresponding source repository. Based on the role policy read in the same snapshot, it further determines whether the domain name query operation is approved, whether each output field requested is approved, and whether the selected delivery method is approved. If the field request is empty, contains unknown fields, or contains unauthorized fields, the task is rejected. After the query authorization is approved, the access context for the domain name query business operation is constructed separately. This context retains the user, project, role, platform, and logical repository in the repository access authorization. The original dependency records are copied item by item for the dependencies used in this repository access authorization without being replaced by another newer snapshot.
[0066] The task envelope is stored on the server and includes the task identifier, source logic repository, domain name query access context, session location information, original dependency record, approved domain name range for repository mapping, standardized query parameters, approved output fields and allowed delivery methods. The approved range stores the base domain name and whether it contains subdomain tags according to the domain name tags. In this specific implementation, the base domain name is the domain name registered by the R&D department consisting of the two tags "example" and "test". When matching, the domain name is converted to lowercase unified international domain name encoding and the last root dot is removed. Only targets that are exactly equal to the base domain name or match the complete tag suffix when subdomains are allowed are accepted. Targets containing paths, ports, address literals or those that cannot be normalized are rejected.
[0067] One record in the approved domain range stores the base domain name consisting of two tags, example and test, and the allowed subdomain tags. The target domain name consisting of three tags, api, example and test, is approved based on the complete tag suffix. The target domain name consisting of two tags, fakeexample and test, and the domain name consisting of four tags, example, test, other and test, are rejected. The intelligence query only uses the approved domain name as the query parameter for the registered intelligence service and does not directly concatenate the domain name into an arbitrary network access address. If the remote end requests to continue querying another domain name, a new pending unit is created and the approved range is re-examined. The envelope boundary cannot be expanded due to the remote end's suggestion.
[0068] The target domain name in the query parameters must come from the source logical repository specified by the task and fall within the approved domain name range. The server saves the repository object identifier and extraction location of the extracted domain name for source verification. If the domain name is extracted from previously obtained repository content, it is also required that the original dependencies carried by the content be consistent with the current repository access authorization dependencies item by item. The old repository content is not reattached to the new dependency. The query fields are saved in a fixed order to remove duplicates. After the task envelope is created, the client is prohibited from modifying the target, scope, context or dependencies. Modifying the query parameters is a new task and re-authorization.
[0069] The authorization processor hands over the warehouse access credentials and authorization cache to the S3 request verification process, writes the derived query task envelope into the internal task table and delivers it to the internal queue with the task identifier. The queue message only serves to wake up the task execution node. The execution node must read back the server task envelope to obtain the complete authorization binding. It cannot send a query to the remote platform simply because an allow flag appears in the queue message.
[0070] In this specific embodiment, S3 includes:
[0071] After the task execution node obtains the access request and credential identifier, it re-executes the context construction of S1 based on the verified session associated with the request. It reads the original binding from the server-side credential table and compares the user, project, activity role, platform instance, logical repository, and operation item by item according to the field consistency matching algorithm. It also verifies that the session location information is consistent with the current session. If there is an authorization cache hit, it also compares the access context, session identifier, and dependency records in the cache. If any difference is found, the request is rejected. The cache stores data that can be used only for the preparation stage and cannot directly trigger external network calls.
[0072] In this specific implementation, each actual request delivered to the remote platform is treated as a sending unit. After the task execution node prepares the request method, specification parameters, request body and sending unit identifier, it submits them to the unified delivery coordinator. Each execution node does not directly hold an external sending connection. The coordinator is located at the final sending position connected to the remote platform. All warehouse proxy requests and domain name information query requests are sent through this position. Background retries, requests to continue after redirection and remote pagination requests all generate new sending units and are re-verified.
[0073] The coordinator extracts the complete dependency record from the server-side binding record, sorts it by status identifier, and applies for read locks for each status in a unified order. After acquiring all read locks, it starts a new authoritative read transaction, reads the current committed status by status identifier, does not use the old snapshot of S2, does not read the version in the asynchronous replica or the authorization cache, and requires that the current version is completely equal to the dependency version, the status is not expired, and the corresponding content still allows the current request. If any condition in membership, role, session, or repository mapping fails, the sending unit will be marked as rejected.
[0074] After acquiring the read lock, the coordinator re-verifies the request, credentials, and context binding of the cached hit within the same execution protection, and reviews the credentials and session expiration conditions. If any state actually used is missing in the dependency, or if there are duplicate conflicts or the authoritative state cannot be read, the request will not be sent. The coordinator read lock is not released when the read transaction ends. The read lock continues to cover the subsequent mapping resolution and actual request delivery, avoiding leaving an unprotected interval between completing the database query and sending the connection.
[0075] After the repository request is verified, the coordinator only uses the platform instance and real repository identifier in the verified mapping state to construct the target address. It does not accept the complete remote repository address passed by the client to overwrite the mapping. The platform connection configuration and credential reference are included in the version management along with the mapping state. The coordinator uses the access credentials in the server credential storage area to attach the platform authentication information and sends the request through the connection registered by the platform instance. The record returned to the requester does not contain the platform credentials. When a redirection that requires changing the target repository or platform is encountered, the current unit is stopped and the ownership and authorization process is restarted.
[0076] For domain intelligence tasks, the coordinator reads back the task envelope from S2, verifies that the source logical repository and mapping, access context and session location of the envelope are consistent, obtains a read lock according to the original dependencies of the envelope and verifies the repository access conditions, and then uses the same role policy to verify that the domain query operation, the approved output fields and delivery method are still allowed. The specification target is matched with the approved domain name range of the envelope tag by tag. Only after all are passed will a request containing the target and specification query parameters be sent to the registered intelligence service. Other domain names returned by the intelligence service do not directly form new query targets.
[0077] The execution protection of a sending unit begins with acquiring all read locks and continues until the complete message of the request is delivered through the final outgoing connection controlled by the coordinator, or until the connection is explicitly terminated and further sending is prohibited before delivery is completed. In this implementation, messages successfully written to the transport layer of the final connection and taken over by that connection are considered as messages actually sent by the server. Queuing internal tasks or enqueuing ordinary business buffers are not considered as sending completion. The subsequent transmission and remote execution of messages delivered to the final connection are not within the scope of revocability.
[0078] The coordinator sets a five-second write wait limit for connections in progress. When the limit is reached, the sending channel is closed and any remaining bytes not yet committed to the final connection are cancelled. The read lock is released only after confirming that no background write task continues to run. Protection that is still being delivered is not released directly due to timeout. Remote response waiting does not occupy the send read lock. The response is received by S4 and isolated and saved after asynchronous return. If the connection fails and it is unclear whether the request was executed remotely, the unclear sending status mark is retained, and automatic retry by bypassing re-verification is prohibited.
[0079] Before sending, the coordinator persists the sending unit identifier, task or credential identifier, access context, session location information, and the complete dependencies used in this transaction as an immutable request record. External responses are associated with this request record, and the dependencies used when the request was sent are used as the original dependencies of the result. The latest state is not read and the version is not re-attached when receiving the response. If the request is not successfully sent, the failure state is retained and no success result is generated. Network responses are allowed to be later than the return of the S5 change commit.
[0080] In this specific implementation, the task envelope holds mapping version nine, and when the coordinator reads mapping version ten, it still refuses to send even if the logical repository identifier and the real address surface are the same. When all verifications pass, it records the sending units using versions twelve, seven, three and nine, and hands over the response receiving handle and immutable request record to S4. Each subsequent appended remote request re-requests the read lock and verifies the original dependency, and cannot use the passing result of the previous sending unit.
[0081] In this specific embodiment, S4 includes:
[0082] The response receiving node uses the immutable request record stored in S3 as the source, writes the execution result of the repository proxy and the domain name information to the server isolation zone. The result record includes the result identifier, task or sending unit identifier, original access context, session location information, original dependency record, result content location and completion status. The isolation zone is only open to internal services. The client result identifier is only used for location and cannot be used for reading authorization. Asynchronous responses are directly passed through without going through the still maintained client connection.
[0083] The domain intelligence results also associate the source logic repository, approved domain range, query parameters and approved output fields in the task envelope. The result resolver stores the identified fields according to the registered response mode, and saves the domain name, resolution address and other attributes returned by the service separately. Unauthorized attributes are still not open to the client. Responses that cannot be associated with request records, have inconsistent source tasks or missing fields, or fail to resolve are marked as undeliverable. Even if permission changes have occurred when the data is received, the original dependencies are retained and isolation is maintained.
[0084] The result reading entry reconstructs the access context for the verified session and the resource specified in the request. The business operation is determined according to the interface registration relationship of S1. Then, the read-only result record is located from the result identifier. Reading, result cache hit, pagination and export all enter the same delivery coordinator. The coordinator first locates the original dependency and obtains all state read locks. Then, within the execution protection, the current context is compared with the binding of the result and task envelope item by item. Delivery is rejected when the session location is different, the identity is inconsistent or the source repository is inconsistent.
[0085] In the new authoritative read transaction after acquiring the read lock, the coordinator reads the state item by item according to the original dependencies, requiring the versions to be completely identical and re-verifying session validity, membership, active roles and repository operation permissions. The domain information results also verify the query operation, the output method and the authorization of each field to be output. Fields not approved in the task envelope are not added to the old result output even if the current role additionally allows them. If the request contains unapproved fields, the delivery is rejected. The output scope of the original task is not expanded without the current permission scope.
[0086] After verification, the coordinator reads the data block from the isolation zone and generates an independent output buffer according to the approved output fields in the envelope. Only these fields and paging control information without business data are written to the result response. Nested objects are projected layer by layer according to the registered field path. Error messages do not include the original response content. If the request is for repository content rather than domain information, only the result content corresponding to the original repository request is released. Both types of results must complete context verification, dependency verification and actual output within the same protection.
[0087] The result cache stores the location of the result content and the original binding. Its index is generated according to the source logical repository, access context, session identifier, original dependency record, approved domain name range, standard query parameters and approved output field encoding. After a candidate cache hit, the complete value is compared item by item. If any item is different, it is considered a miss. A hit only avoids repeated retrieval of content. It cannot skip the permission verification of the result output location. The result cache must not be delivered through a public address that can be directly read by the client.
[0088] In this specific implementation, each data block actually delivered to the requester is taken as an output unit. A complete response of a normal result, each page of a pagination, and each data block exported by a block are respectively protected. Each page of a pagination is set to one hundred records, and each exported block is set to a maximum of two hundred and fifty-six thousand bytes and is split at the boundary of the complete record. Single records exceeding the block size are treated as independent protected units. These values control the delivery granularity of this implementation and do not change the rule that each unit is re-verified.
[0089] The pagination cursor stores the result identifier, task identifier, original dependency summary, next record position, and approved output fields on the server. The client only holds an unpredictable cursor identifier. The next page is located based on the cursor to locate the original result and verify the complete binding. Page numbers or cursors are not used as authorization proofs. The export queue only stores the internal position of the unit to be output. It is forbidden to generate long-term download addresses that are not verified by the coordinator. The delivered position is recorded after each block is output. The next block is verified after re-locking.
[0090] The output read lock is held until the data block is taken over by the final client connection controlled by the coordinator, or until the output is terminated and the background writing of the unit is stopped. It cannot be released prematurely when serialization is completed, compression is completed, or it is queued for asynchronous business transmission. The upper limit for output connection write waiting is also set to five seconds. After the time limit expires, the channel is closed and the remaining content is confirmed to be no longer delivered. If the client reads slowly, the subsequent output units are paused. The part that has entered the final connection is regarded as delivered and is not claimed to have been withdrawn based on the result of termination.
[0091] When S5 changes any version in the original dependency, the subsequent read lock on the output unit fails to be verified. The coordinator stops the data blocks that have not yet been delivered, as well as the subsequent pages and exported blocks that have not yet started. The failure response only carries the task or result invalidation status. The response that arrives after the query has been sent continues to be written to the isolation area and saves the old dependency. The old result and result cache remain immutable. The original dependency is not changed to the new version to restore the readable state.
[0092] After reauthorization, the server regenerates the repository access authorization, query authorization, and new task envelope according to S2, and re-executes the query according to S3, and saves the new response as a new result object. Even if the query target is the same as the old task, the old content is not directly modified to attach the new dependency. In this embodiment, after the first page output, the mapping version is incremented from nine to ten, so the original result on the second page is rejected. Only the result generated by the new task using version ten enters the new output verification process.
[0093] The coordinator saves the result identifier, original dependencies, delivery method, actual release field, delivery completion or rejection status, and completion location of each output unit to the delivery record. The record is used to locate the processing status of subsequent pagination and export. The permission determination always reads the authoritative status. The delivery record or the previous successful output record itself does not generate authorization for the next output unit.
[0094] In this specific embodiment, S5 includes:
[0095] The access control entry receives change events such as revoking member authorization, modifying role policies, switching session activity roles, invalidating sessions, and changing repository mappings. It locates the affected status identifier from the authority status. If the change event is missing a target identifier or expected version, it will refuse to process it. For complete change events, it saves the event identifier, target identifier set, expected old version, and new status content. Member revocation modifies the member authorization status, role policy modification affects the corresponding role policy status, role switching and session cancellation modify the corresponding session status, and changes in the real repository, platform affiliation, platform credential reference, or approved domain range all modify the repository mapping status.
[0096] Each server execution node applies for read-write locks through the same unified delivery coordinator. The lock table uses the status identifier as the key to maintain a set of read holders, a set of write holders, and a waiting queue. The request sending and result output obtain read locks for all states of the dependent records, and the change processing obtains write locks for all affected states. A write lock cannot be granted if a read holder exists for the same state, and a read lock cannot be granted if a write holder exists. This implementation adopts a write waiting priority rule, which prevents new read requests from overriding existing write requests when they are already in the queue.
[0097] For multiple locks, the coordinator first sorts the status identifiers in the same byte order and removes duplicates, then requests them one by one in this order. Only after all locks are acquired will the verification or modification process begin. It does not upgrade a read lock to a write lock while holding one. If a change is found to involve other states not listed in advance, the uncommitted operation is abandoned, the acquired locks are released, and a new request is made with the complete set of identifiers. The upper limit for waiting for locks is set to three seconds. If all required locks cannot be acquired, the acquired locks are released and the process returns to the inactive state. Partial lock acquisition success is prohibited from being regarded as an execution permission.
[0098] The coordinator associates lock requests with unit status. The unit status is sequentially: waiting for lock, holding lock, verified, in delivery, and completed or abandoned. Only verified units can enter the in delivery state. If a unit is canceled while still waiting for lock, it is removed from the waiting queue. If cancellation is received while in delivery, the delivery channel is stopped and the backend write is confirmed to be terminated before it is changed to abandoned. If the same unit identifier is received repeatedly after the unit is completed, the completion record is read and no more is sent. The same unit identifier cannot correspond to different request contents.
[0099] After the change processor acquires all write locks, it starts a write transaction in the authoritative state database, rereads the target state and compares it with the expected old version. If the expectation is not met, it rolls back and lets the management entry reread the state. If the expectation is met, it modifies the content of each affected state to the event-specified value, and increments each version by one based on the original value. All content, version and event completion records are committed in the same transaction. It does not write the content first and then update the version asynchronously. If the transaction fails, it rolls back the whole and does not return a success message.
[0100] In this specific implementation, the version adopts the database decimal integer type and prohibits wrapping. When it approaches the storage limit, it refuses to continue changing and stops granting new authorizations to the state. It continues to increment after expanding the representation capabilities. The previous role strategy or warehouse mapping content is restored and still increments on the current version. When the mapping changes from the real warehouse 101 to 102 and then back to 101, the version changes from 9 to 10 and 11 in turn. The dependency of the original version 9 is not valid again due to the content restoration.
[0101] The status deletion uses the retained identifier for invalid records, writes the previous version plus one and the invalidation mark, does not physically reclaim the status identifier and its version history, and when re-establishing the same business relationship, a new status identifier is assigned or restored on a higher version of the retained identifier. It is prohibited to reassign previously used status identifiers and version pairings. When querying by business key, only a unique valid status is returned. When querying by the status identifier of the old dependency, invalid records can still be found, thus explicitly rejecting the old voucher.
[0102] After a write transaction is successfully persisted and committed, the coordinator releases the write lock and returns a successful change to the management entry. If the commit result is unclear, the addition and output of related states are blocked. The transaction commit record is queried based on the event identifier. If it is confirmed that the transaction has been committed, it is returned as a completed event. Only if the rollback is confirmed can reprocessing be allowed. The same event identifier cannot be retried with an incremented version. A successful change cannot be claimed based solely on the new state in memory when the database connection fails.
[0103] The write transaction for permission changes also restricts the write source of the management entry. The database write account is only used by the change handler, and other business nodes only hold read-only accounts. The background repair and batch import must also submit change events. The authorized content cannot be directly modified and the old version can be retained. If the state version is found to be missing or smaller than the persisted version, the coordinator will mark the corresponding state as abnormal and stop sending and outputting the state. After restoring the database backup, the version record will be checked first and the state that may be reverted will be disabled before the valid state and authorization will be re-established.
[0104] Each actual request delivered to the remote platform is defined as a sending unit, and each actual result data block delivered to the requester is defined as an output unit. The holding period of the read lock covers the final request delivery of S3 and the final result delivery of S4, respectively. The write lock covers state reading, content modification, version increment and atomic commit. Therefore, when the change acquires the write lock first, the subsequent sending and output can only read the new version and reject the old dependency after the commit. When the sending or output acquires the read lock first, the write transaction waits for the actual delivery of the unit to be completed or to be confirmed as abandoned before committing. After the change is successful, a new delivery unit using the old dependency will not be started. Data that has entered the final connection and operations that have been sent to the remote end will not be rolled back.
[0105] This implementation concentrates lock coordination and final network delivery into a single active coordinator process. Other execution nodes can only submit units through the internal interface and cannot bypass the coordinator to directly connect to the remote platform or return results to the requester. Locks do not automatically release upon lease expiration. When the coordinator loses connection with the database, it stops obtaining new delivery permits. During the coordinator restart and recovery period, global sending and output are prohibited. It first confirms that the old process has terminated and the old outgoing connection is closed. If it cannot confirm that the old process has stopped, the service remains undeliverable to prevent old nodes from continuing to send after the lock expires.
[0106] Each coordinator startup has a unique instance identifier, and its database write session registers this instance identifier. Before starting a state write transaction, the change processor first persists an pending change record containing the instance identifier, event identifier, and affected state identifier. Only after the record is successfully recorded will the state write transaction be executed. The transaction completion record is still committed in the same transaction as the state content and version. The recovery procedure restores the non-deliverable flag of the affected state from the pending change record. At the same time, it closes all write sessions of the old instance on the database side and waits for the database to confirm that all write transactions of these sessions have been committed, rolled back, or terminated and cannot be committed again. The old instance cannot re-establish write sessions.
[0107] After the database confirms the termination of all old instance transactions, the recovery procedure reads the transaction completion records and the latest committed status using the new transaction query. Unresolved changes with completion records are treated as committed, while changes for which the database has confirmed the termination of the transaction but no completion records are treated as uncommitted. Subsequently, the locking tables are rebuilt and the deliverable state is restored. Unresolved flags are only cleared after the corresponding transaction outcome is clear and the state restoration is complete. If the database cannot provide confirmation of transaction termination, the old instance may still be writeable, or the state restoration is not yet complete, global sending and output are prohibited. Table locking, connection disconnection, or waiting for timeout recovery delivery cannot be performed without authorization, thereby preventing old write transactions from being committed late during the new delivery period.
[0108] For domain intelligence query tasks originating from the logical repository, after the change is completed, the approved domain range, query parameters, approved output fields, access context and original dependency records in the task envelope will not be rewritten. Queries that have not yet been sent in the queue will be verified and rejected according to the original dependencies at the final sending position. Result reading, result cache hit, pagination and export will still be checked according to the envelope binding and verified on an output unit-by-unit basis. In addition to the repository access authorization, the authorization judgment of query operations and output fields will be made independently according to the role policy and checked using the current authority status. If any item fails, the corresponding undelivered unit will be stopped.
[0109] If a query has been sent but the member's authorization is subsequently revoked, the late execution result is still associated with the original task envelope and written to the quarantine area. Fields cannot be released on the grounds that the task has been completed or the cache has been hit. After the user regains membership, the dependency must be re-formed, the task envelope generated, and the query re-executed. The coordinator will not replace the dependency of the old result with the restored version. The same processing applies to each page of pagination and each block of export. Even if the previous unit has been successfully delivered, the next unit has no right to skip verification.
[0110] In this specific implementation, the execution order is illustrated by the event of changing the role strategy version 7 to version 8. If the sending unit already holds the read lock of the strategy, the change will wait for the sending to complete and then submit version 8. After that, the output of the result with the original dependency still being version 7 will be rejected. If the change submits version 8 first, the original sending unit will directly reject the change due to version mismatch after acquiring the read lock. The above are two execution paths derived from the lock order, used to illustrate the control rules and not as actual performance data.
[0111] The change processor compares submitted event records with event identifiers. If the same identifier corresponds to different targets or different new content, the event is rejected and the original event's successful result is not reused. The coordinator matches the dependencies of the unit to be delivered according to the affected status identifier. If an old version is matched, it is only marked as unverified and delivery is not allowed based on the queue scan results. The actual sending and result output are still checked within the read lock. Old tasks that are not scanned will also be rejected by the same version comparison rule.
[0112] After successful submission, the server searches for the old credentials, authorization cache, and reverse index of the execution result according to the affected status identifier, asynchronously marks and reclaims expired storage. Delays or failures in the reclamation task do not affect the final sending and output of the version rejection. The authority status, expiration mark, and version record are not deleted with ordinary cache cleanup. The change event completion record saves the affected identifier, old version, new version, and transaction completion status for subsequent management retry and delivery rejection tracking. The time when the permission takes effect is always determined by the atomic commit.
[0113] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.
[0114] This invention integrates the status identifier and version used for authorization judgment into access credentials, authorization caching, request sending, and result output, ensuring that dependency records have a traceable origin. The actual repository address is resolved on the server according to the verified mapping, and derived queries also retain the source repository and original dependencies, thereby constraining the conditions for repository access and the use of associated results to the corresponding authoritative status.
[0115] The improvements of this invention are achieved by implementing protective coordination for change submission, request sending, and result output, and by re-verifying each sending and output unit. Its control boundaries ensure that no new sending or output based on old dependencies is added after a successful change submission; remote operations that have already been issued may continue to execute, and delivered data will not be retroactively withdrawn. Asynchronously returned results retain their original dependencies and enter the server isolation zone, where they are re-executed as a new task after re-authorization.
Claims
1. A method for access control of private code repositories based on permission versions, characterized in that, include: S1. Construct an access context from the verified session, including user, project, activity role, platform instance, logical repository, and operation; S2. Read member authorization, role policy, session state, and repository mapping from the consistent snapshot according to the access context, generate dependency records containing each state identifier and monotonically increasing version, and bind access credentials and authorization cache together with the access context and dependency records after authorization is passed; S3. Verify the access request, access credentials, and access context of the hit authorization cache, and place the dependency records, authoritative state verification, and request sending in the same execution protection at the final sending position. After verification is passed, parse the real repository on the server according to the repository mapping and proxy the sending of the request to obtain the execution result; S4. Bind the execution result to the access context and original dependency record that produced the result. At the result output position, place the access context verification between the result read request and the execution result, the original dependency record and the authority status verification, and the result output within the same execution protection. Output only after both verification and validation are passed. S5. Atomically commit changes to member authorization, role policy, session state, or repository mapping with the corresponding version increment. Make the change commit mutually exclusive with execution protections involving the same status identifier. After successful commit, reject the request sending and result output corresponding to the old dependency record.
2. The method for access control of a private code repository based on permission versions according to claim 1, characterized in that, S1 includes: The user identifier and session identifier are determined based on the verified session, and the project identifier and activity role identifier are determined based on the confirmed project and activity role in the session. The system verifies the platform instance, logical repository, and operation execution attribution specified in the access request, and generates an access context. The session identifier is used as the basis for locating the session state, and the combination of user identifier, project identifier, activity role identifier, platform instance identifier, logical repository identifier, and operation identifier is used as the matching item for the access context. Access credentials or authorization caches are not reused between access contexts with different matching items.
3. The method for access control of a private code repository based on permission versions according to claim 1, characterized in that, S2 includes: From the server-side state storage that stores the authoritative state, read the state content and version of member authorization, role policy, session state, and repository mapping that are effective for the access context using the same snapshot; use the unique identifier of each state on the server as the state identifier, and pair the state identifier with the version to form a dependency record; determine the access permission decision based on the read state content if the session is valid, the user has the qualifications of a project member, the active role allows the operation, and the repository mapping is valid; The server stores the binding relationship between access credentials, access context, and dependency records that cannot be modified by the client. The authorization cache stores the same binding relationship and authorization determination. The cache index contains access context and dependency records.
4. The method for access control of a private code repository based on permission versions according to claim 1, characterized in that, S3 includes: reconstructing the access context based on the verified session associated with the access request; comparing it item by item with the access context bound to the access credentials; if there is an authorization cache hit, also comparing the access context bound to the authorization cache and the dependency record; reading the authoritative state using the status identifier in the dependency record; verifying that each version is equal and the corresponding state still allows operation; not replacing the version in the authoritative state with the version in the authorization cache; refusing to send the request if any comparison or verification fails; if the verification passes, only using the repository mapping corresponding to the dependency record; resolving the logical repository to the real repository within the platform instance on the server side; and using the platform access credentials stored on the server side to complete the proxy sending.
5. The method for access control of a private code repository based on permission versions according to claim 1, characterized in that, S4 includes: Save the execution result along with the access context and dependency records used when the request was sent, and use the dependency records used when the request was sent as the original dependency records; For result reading requests, the access context is reconstructed, checked against the access context bound to the execution result, and the authoritative status is read using the status identifier in the original dependency record. Each version is verified to be equal and the corresponding status still allows operation. The access context verification, original dependency record verification, and delivery of the execution result to the requester are included in the same execution protection at the result output location. Delivery is rejected if the verification fails.
6. The method for access control of a private code repository based on permission versions according to claim 1, characterized in that, S5 includes: for events such as revoking member authorization, modifying role policies, switching the active role of a session, invalidating a session, and changing repository mappings, updating the corresponding authority state and incrementing the corresponding version, and committing the updated state content and version in the same transaction; when the state is restored to the previous content, the version is still incremented; when the state is deleted, the state identifier, the incremented version, and the invalidation flag are retained; it is prohibited to pair used state identifiers with versions and reassign them to valid states; a change success is returned only after the atomic commit is completed; authorization is determined based on authority state and version; asynchronous deletion of old access credentials, authorization cache, and execution results only reclaims storage records.
7. The method for access control of a private code repository based on permission versions according to claim 6, characterized in that, The server coordinates read-write locks for the status settings corresponding to all status identifiers in the dependency record; after the request to send and the result output are respectively acquired, the authoritative status is verified, and the read lock is held until the actual sending or actual output is completed, or the sending or output is abandoned, and then the read lock is released. After acquiring the corresponding write lock, the change of authoritative state is performed by updating the state, incrementing the version, and atomically committing. After the commit is completed, the write lock is released. Each server execution node performs the aforementioned operations through the same lock coordination entry point, acquiring multiple locks in a unified order of status identifiers. If an exception occurs where the required lock cannot be acquired or the authoritative status cannot be read, the request sending and result output will not be executed.
8. The method for access control of a private code repository based on permission versions according to claim 7, characterized in that, For domain information queries originating from the logical repository, in addition to repository access authorization, authorization is independently determined for query operations and output fields based on role policies. After authorization is granted, a task envelope is generated and saved on the server. The task envelope is bound to the source logical repository, access context, original dependency record, domain range approved by repository mapping, query parameters, and approved output fields. The original dependency record is taken from the dependency record used for repository access authorization when the task envelope is generated. The scope of the approved domain names bound to the task envelope is used as the boundary of the query target, which constrains the query target to be within the scope of the approved domain names. The task execution node verifies the original dependency records and query authorization at the final query request sending position, and sends the query request according to execution protection. If the verification fails, the request is rejected.
9. The method for access control of a private code repository based on permission versions according to claim 8, characterized in that, After the domain information query is completed, the results are first written to a server isolation area that is not open to the requester, and saved in association with the task envelope and the original dependency record. For reading the execution results, result cache hits, pagination, and export, the binding relationship between the requester's access context and the task envelope is checked respectively. The original dependency record and output field authorization are re-verified within the execution protection of the result output position. After the verification is passed, only the results corresponding to the approved output fields in the task envelope are released. The index of the result cache includes the source logical repository, access context, original dependency record, approved domain range, query parameters, and approved output fields. It is forbidden to replace the original dependency record of the existing execution results or result cache with the updated dependency record.
10. The method for access control of a private code repository based on permission versions according to claim 9, characterized in that, Each actual request delivered to the remote platform is defined as a sending unit, and each actual result data block delivered to the requester is defined as an output unit. The sending unit and the output unit are delivered only after obtaining execution protection and completing the verification of the original dependency records. Each page after pagination and each data block exported by block are respectively used as output units. When the original dependency record becomes invalid, the sending and output units that have not yet been delivered are stopped. The subsequent return results of the sent queries are still written to the server isolation area and the original dependency record is maintained. When reauthorization is performed, the task envelope is regenerated and the query is re-executed.
