234 results about "Commit" patented technology

Systems and methods for securing transactions in accordance with various embodiments of the invention are illustrated. One embodiment includes a method for confirming token ownership rights. The method generates a pre-image value using a random number generator. The method generates an action request that corresponds to an action performed cryptographic token(s). The method derives a commit output based on the pre-image value. The method generates a commit request that obfuscates the action request based on the commit output and submits the commit request to an immutable ledger. The method receives a confirmation when the commit request is approved by the ledger. When a reveal request referencing the commit output is published, the method receives a confirmation of at least one of: the reveal request being published, that the reveal request comprises a reference to the commit output, or that the action request has been approved.

The invention discloses a transaction processing mechanism optimization method and system for time series data, and belongs to the technical field of databases, and the method realizes a differentiated ACID support mechanism, strengthens atomicity and durability guarantee, and weakens consistency and isolation requirements; comprising the following steps: designing a collaborative architecture of a transaction system and a pre-write log WAL, and establishing a binding relationship between a transaction state and WAL writing; generating a WAL record only for the successfully submitted transaction operation, and performing persistent storage by adopting a batch group submission strategy; transaction scheduling is realized through a lightweight transaction manager, and the life cycle of a transaction request is managed; the functions of efficient writing of transaction granularity, log storage and rapid recovery are realized through a pre-writing log manager; through intelligent Checkpoint background service, based on a periodic incremental check point mechanism, compression merging and space recovery of the WAL file are realized. According to the invention, the performance breakthrough of the time sequence database in a high-concurrency write-in scene can be realized.

A computer system and method are disclosed for replicating logs in a distributed environment. The method includes identifying a write input / output (I / O) operation and identifying a log to be replicated based on the write I / O operation. The log is then persisted to local non-volatile memory in the computer system. Subsequently, the log is replicated to multiple remote hosts, where each remote host of the plurality of remote hosts stores the log in its corresponding local non-volatile memory without de-staging the log to a backing store. The write I / O operation is committed once the log is replicated to at least a subset of the remote hosts that forms a quorum. Finally, the log is de-staged to the backing store after the write I / O operation is successfully committed.

A computer-security architecture removes activation authority from client-facing purchase flows. A server records a digital entitlement in an INACTIVE state and issues a presentation artifact. A verification service accepts messages only from trusted origins carrying freshness-bounded evidence and validates using (i) stateless keyed recomputation over a time-windowed payload, (ii) confirmation that token-rail authorization data maps to a registered association within a policy freshness bound, or (iii) a server-maintained session. Activation occurs only on an authoritative commit path that enforces no activation without a durable audit record and effective-once behavior: either a single ACID transaction that conditionally updates state and writes an insert-only audit in the same commit, or an append-only activation ledger with idempotent materialization. Access controls deny issuance-facing code permission to set ACTIVE. Expiration is timer-free via batch or TTL evaluation.

Distributed execution of transactions may be performed across shards of a scalable database table. Instructions to perform as part of a transaction with respect to one or more database tables may be received. The instructions may be evaluated with respect to metadata obtained for the database tables to determine an assignment distribution of computing resources of the database system to data that can satisfy the access request. The commit protocol for the transaction may be determined according to the assignment distribution of the computing resources. After a request to commit the transaction is received, the transaction may be committed according to the determined commit protocol.

Methods, computer systems, computer-storage media, and graphical user interfaces are provided for efficiently generating code development summaries. In embodiments, commit message data for a commit message associated with code is obtained. In embodiments, the commit message includes a description associated with a corresponding modification in the code. Thereafter, a model prompt to be input into a large language model is generated. The model prompt includes the commit message data. As output from the large language model, a code development summary is obtained that summarizes the commit message data for the commit message associated with the code.

A data processing service uses minor compactions for committing transactions to a data table. The service may receive requests to commit transactions to a data table and write metadata for the transactions to log files, and generate a checkpoint file aggregating the transactions described in the log files to compute a data table state at a first time. The service may receive requests to commit a set of transactions and write metadata for the set of transactions to a set of log files. The service may determine that a number of log files in the set of log files reaches a threshold commit number, generate a minor compaction file aggregating the set of transactions, and generate a second checkpoint file aggregating the data table state at the first time with information from the minor compaction file to compute the data table state at a second time.

Clock times may be stored at nodes of a database system that are used to provide access to database data using Multi-Version Concurrency Control (MVCC) and implement isolation for distributed transactions. When an access request is received at a processing node of a database, the snapshot time of the access request is determined. The snapshot may be a range of time, with an earliest and latest timestamp. If the snapshot time has a latest time stamp greater than a current timestamp in the clock time, then the clock time may be updated. The clock time and snapshot time may be used to implement time-based MVCC to select a version of a tuple stored in the database to use for performing the access request.

The invention discloses a fault fallback method and device in a multi-agent cooperative system, equipment and a medium, and the method comprises the steps: recognizing a plurality of target agents used for jointly executing a target transaction in the multi-agent cooperative system according to a target transaction operation request; the target agent is used for executing one atomic operation in the target transaction; after a transaction submission instruction is sent to each target agent which completes preparation in the preparation stage, whether an execution fault occurs in the execution process of the target transaction is monitored in real time in the submission stage; when the target execution fault is detected, at least one fault agent generating the target execution fault is positioned in the target agents; according to the fault agent, the local or complete rollback operation of the target transaction in the submission stage is executed, and according to the technical scheme of the embodiment of the invention, by monitoring multi-agent transaction execution in real time, accurately positioning the fault node and supporting the local or global rollback operation, the fault-tolerant capability of the system is remarkably improved, and the transaction consistency is also ensured.

Methods for capturing temporary database tables for analyzing a database query are provided. Aspects include obtaining a capture pattern and the database query having a sequence of statements. Aspects also include determining that a first statement of the sequence of statements matches the capture pattern, creating a list of temporary tables based on the first statement, and determining that a second statement of the sequence of statements includes one of a drop, commit, and truncate commands that correspond to a table in the list of temporary tables. Aspects further include creating a copy of the table in the list of temporary tables, generating an updated first statement by replacing a reference to the table in the list of temporary tables with a reference to the copy of the table, removing the table from the list of temporary tables, and executing the database query by performing the sequence of statements.

The invention discloses a distributed system transaction processing method and device based on a two-stage commit protocol, equipment and a medium, and relates to the technical field of distributed computing, and the method comprises the steps: obtaining transaction data sent by a coordinator before a preparation stage; sending a first response message to the coordinator and the participants based on the transaction data, so as to send an operation instruction to each participant according to the first response message; receiving a second response message sent by each participant, and storing a target number of copy data based on each second response message; if the operation instruction is not received in the target time period, processing the transaction data based on the copy data; and obtaining a corresponding processing result, and synchronizing the processing result to the target participant so as to optimize the two-stage submission protocol. By sharing the transaction state information among the participants, the participants can still complete transaction submission or rollback under the condition that the coordinator loses efficacy in the system, so that the occurrence of indefinite blockage is avoided.

A system and method for managing repositories may include or involve aggregating a plurality of repositories, where each repository may include data elements of a computer model, determining a state for the computer model, and fetching one or more of the data elements based on the determined state. In some embodiments, aggregated repositories may include at least two or more of: a remote repository, and a local repository—and the aggregating may include associating a single address with data elements from different repositories. In some embodiments, determining a state for the model may include comparing a stored version of the model to a reference version of the model using, e.g.: a checksum operation, a model commit, and / or a hash function. Some embodiments may include managing repositories based on a repository layout, which may describe a hierarchy between model data elements and / or aggregated repositories.

Systems, computer program products, and methods are described herein for evaluating computing programming code changes using AI to improve computing performance and component consumption. The present invention is configured to identify at least one code commit change; determine whether the at least one code commit change matches at least one runtime restriction statement; classify the at least one code commit change as a restriction code commit change; identify at least one object reference, at least one class, and at least one method associated with the restriction code commit change; initiate a trigger-class method trace module on the restriction code commit change, wherein the trigger-class method trace module generates at least one runtime restriction weight associated with each restriction code commit change; and initiate a trigger flow trace module on the restriction code commit change and generate at least one suggested code commit change.

The invention particularly relates to a distributed time series data cross-node atomic writing and transaction management method. According to the distributed time series data cross-node atomic writing and transaction management method, a coordination node receives a time series writing request, generates a unique TID and issues the unique TID; the storage node writes the data into a pre-write log WAL, marks the data as pending, and establishes mapping between the TID and log entries; the cooperative node sends a pre-submission instruction, and the node responds after being ready; and if verification is passed, broadcasting submission is carried out, a formal storage update version is written, otherwise, rollback is carried out, operation is cancelled according to WAL, and finally associated logs and states are cleared. According to the distributed time series data cross-node atomic write-in and transaction management method, end-to-end atomicity, consistency, low delay and rapid recovery of cross-node time series data write-in are achieved, a write-in path only needs one-time WAL write-in, synchronous blocking is avoided, and the concurrent throughput performance is remarkably improved; and the scheme does not invade an upper-layer application interface, and can be reused in any distributed storage system supporting the WAL.

A consensus protocol-based replication approach is provided. For each change operation performed by a leader server on a copy of the database, the leader server creates a replication log record and returns a result to the client. The leader does not wait for consensus for the change operation from the followers. For a commit, the leader creates a commit log record and waits for consensus. Thus, the leader executes database transactions asynchronously, performs replication of change operations asynchronously, and performs replication of transaction commits synchronously.

The embodiment of the invention relates to the technical field of electronic information, and provides a supply chain transaction asynchronous consistency implementation method and related products, and the method comprises the steps: configuring a preset aspect logic for a target business method, and generating a proxy object; executing a preset aspect logic of the proxy object, and determining a transaction context state of a target transaction correspondingly executed by the target business method based on the meta-information of the target business method; when the transaction context state is a transaction state, determining a target execution mode of the target transaction; in response to a submission instruction for the target transaction, adding a message record of the target business method to a preset local message list; executing the target transaction according to the target execution mode, if the execution succeeds, updating the execution state to be successful, and if the execution fails, repeatedly executing the target transaction within a preset retry time threshold value according to the target execution mode. According to the embodiment of the invention, on the premise of not changing the core business process logic, the cross-system transaction consistency is ensured.

In a pipeline configured for out-of-order issuing, handling translation of virtual addresses to physical addresses includes: storing translations in a translation lookaside buffer (TLB), and updating at least one entry in the TLB based at least in part on an external instruction received from outside a first processor core. Managing external instructions includes: updating issue status information for each of multiple instructions stored in an instruction queue, processing the issue status information in response to receiving a first external instruction to identify at least two instructions in the instruction queue, including a first queued instruction and a second queued instruction. An instruction for performing an operation associated with the first external instruction is inserted into a stage of the pipeline so that the operation associated with the first external instruction is committed before the first queued instruction is committed and after the second queued instruction is committed.

The present subject matter discloses techniques to efficiently update a resource. The resource is updated in response to changes in an operational status indicator associated with the resource. A first signal is received in response to change in the operational status indicator. Based on the operational status indicator, it is ascertained whether to trigger generation of a virtual instance of a modification enabling framework for generating a data file. Further, a second signal is received in response to subsequent change in the operational status indicator. Parsing of at least one of an executable content and a commit message from the data file is then triggered to generate an updated specification that provides an updated overview for the resource. Further, a resource updation signal is generated to associate the updated specification with the resource.

The invention discloses a construction method and device of an incremental upgrade patch, electronic equipment and a storage medium, and relates to the technical field of computers, a file list and a change type are extracted from a code submission record, difference comparison is performed on files of an original version and a target version based on the information to generate code difference data, and the code difference data are sent to a server; therefore, the problem that the upgrade package contains a large number of redundant codes or key change contents are omitted and the upgrade accuracy and reliability are affected due to the fact that only a file name or a directory structure is used as a change judgment basis in an existing incremental upgrade method can be solved; the technical effects of improving the accuracy and reliability of incremental upgrading and reducing upgrading package redundancy are achieved.

The invention discloses a database replication method and device, equipment and a storage medium, and relates to the field of distributed systems.The method comprises the steps that a database write-in request of a target database is obtained through a client API, nested key values are generated based on the database write-in request, and all the nested key values are combined to determine a target transaction; determining a main node and auxiliary nodes based on a distributed consistency algorithm, packaging a target transaction as an initial log entry by using the main node, synchronizing the initial log entry to the auxiliary nodes, and obtaining synchronization confirmation of each auxiliary node; wherein the synchronization confirmation is information fed back after the secondary node completes synchronization of the initial log entry; and when the number of the auxiliary nodes feeding back the synchronization confirmation is greater than a preset threshold value, submitting and marking the initial log entry to obtain a marked log entry, executing a database write-in operation in the marked log entry by using a state machine, updating a corresponding target database, and returning an operation execution result to the user side. And the consistency between the data copies is ensured.

A method may include: a broadcaster computer program generating, for participants in a network in a transaction, a commit, an audit token, and a proof of consistency; the broadcaster computer program broadcasting, the commits, the audit tokens, and the proofs of consistency for each participant to all participants in the network; the participant computer programs generating complimentary commits, complimentary audit tokens, complementary proofs of consistency, proofs of equivalency, and a proof of assets; the broadcaster computer program receiving from each of the participant computer programs, the proof of assets, the complimentary commit, the complimentary audit token, the complementary proof of consistency, and the proof of equivalency; the broadcaster computer program and / or the participant computer programs verifying, the proofs of assets, the proofs of balance, the proofs of consistency, and the proofs of equivalency; and the broadcaster computer program approving the transaction based on the verification.

The present application relates to the technical field of distributed storage, and in particular to a data sharding processing method and apparatus, a device, a storage medium, and a program product. The method comprises: in response to a split instruction for a first data shard in a database, creating a second data shard; controlling transactions having not been committed in the first data shard to be suspended from entering a commit phase; in response to the completion of commit of transactions having entered the commit phase in the first data shard, controlling transactions having not been read and written in the first data shard to be suspended from entering a read-write phase; transferring first transaction data from the first data shard to the second data shard, wherein the first transaction data is data, among the data of a first transaction, corresponding to the second data shard obtained by splitting; and in response to the completion of transfer of the first transaction data, controlling the transactions in the first data shard to resume entering the read-write phase and / or the committee phase. The present application can reduce the transaction blocking time while ensuring the execution efficiency of distributed transactions.

A server-side restore technique enables restoring of files / folders of a distributed share directly on a file server executing on a node by a file server administrator using self-service restore (SSR) snapshots in accordance with an atomic 2-phase restore-commit transaction. The technique involves share-level restore wherein the entire share state transitions to a previous state of a snapshot, i.e., the granularity of the restore is at the share level (not the file level) for the technique (whereas file level restore granularity is typically used for the client-side restore). The technique is directed to server-side share level restore that allows an “undo” (i.e., rollback) of a previous restore operation into a live snapshot that has become corrupted by a subsequent rollback to a last known good (LKG) snapshot that is uncorrupted. An administration interface may be used to trigger the server-side restore technique for the distributed share.

The invention belongs to the technical field of computer system security. The invention provides a processor architecture optimization method free of side channel attack based on cache line rollback. According to the embodiment of the invention, whether speculative execution of the memory access instruction is consistent with an actual result is checked; and sending a Rollback or Commit signal according to a branch prediction result and an actual branch jump result so as to trigger rollback or submission operation of a cache line. And when the memory access instruction is in a speculative execution state and Cache miss occurs, recording detailed information of the replaced cache line in the Line Buffer. When a Rollback signal is received, the information stored in the Line Buffer is utilized to restore the cache line to a state before branch prediction; when a Commit signal is received, it is confirmed that the previous speculation execution is correct, and the corresponding cache line can continue to be reserved or updated, so that side channel attacks are effectively defended.

A non-transitory computer-readable media, method, and server for detecting and addressing vulnerabilities are described. For example, a server receives a security advisory of a vulnerability of a function in a third-party library, accesses a version control system of the third-party library to identify fix commits that address the vulnerability, determines files corresponding to functions in the third-party library that include the vulnerability, performs a comparison before and after a code change was made to the files, identifies functions that included the vulnerability and have been modified to address the vulnerability, performs a search for component versions that include the individual functions that included the vulnerability, generates an enriched vulnerability description that includes identifiers of package versions that include: fixed versions and vulnerable versions of the functions, and modifies project code in a development system to use the fixed versions of the functions.

In some implementations, a computing device determines that project code in a development system references an older version of a component in a third-party library, determines that the older version of the component has a vulnerability, determines that a newer version of the component in the third-party library addresses the vulnerability, determines code changes associated with the fix commit, determines a subset of the code changes associated with the fix commit that addresses the vulnerability, creates a patch based on the subset of the code changes associated with the fix commit, applies the patch to the older version of the component to create a patched component, validates the patch, and based on successfully validating the patch, builds the patched component and uploads the patched component and information associated with the patch to a registry to enable a software developer to download the patched component.

In some implementations, a fault diagnosis system may track information associated with a first execution of a code pipeline to deploy an updated version of software associated with the code pipeline. The fault diagnosis system may receive an indication of a failure in a second execution of the code pipeline, wherein the second execution of the code pipeline is triggered by a commit of source code to a source code repository. The fault diagnosis system may determine whether the updated version of the software associated with the code pipeline or the source code committed to the source code repository is a cause of the failure in the second execution of the code pipeline. The fault diagnosis system may send a request to plan code development to resolve the cause of the failure in the second execution of the code pipeline.

Method, apparatus and system for assigning a commit sequence number (CSN) to a WRITE transaction in a network having nodes and a global time server. The CSN is defined by a timestamp of the WRITE transaction and an error bound of the timestamp. The WRITE transaction is committed after the timestamp is issued and an amount of time equal to the error bound plus a time adjust value has passed. The time adjust value is based on round-trip times between the plurality of nodes and the global time server. The time adjust value may be the longest expected round-trip time. By waiting for an amount of time equal to the error bound plus the time adjust value, any READ transaction occurring after the WRITE transaction may receive a READ timestamp without any delay, provided the READ timestamp error bound is less than or equal to the time adjust value.

A method for detecting vulnerability fixes in software code is disclosed. A source code file containing source code is obtained. The source code file may, for example, be one of the files of a source code commit. The code changes associated with the file are determined, the code changes indicating differences between a previous version and a current version of the source code. Based on the code changes, a first code representation of the previous version of the source code and a second code representation of the current version of the source code are determined. A first embedding of the first code representation and a second embedding of the second code representation are obtained. By computing a distance between the first and second embeddings, a file-level code change representation for the source code is determined, and the source code file is classified based on the file-level code change representation.

Various methods, apparatuses / systems, and media for detecting fake software tests are disclosed. A processor detects changes in a code against a commit timeline and stores historical record of code change differences over time onto a database. An API call is made to obtain from the database, for only the changed files in a given pull request, a list of the change differences which comes as a structured object. The processor converts the structured object into a single string value containing all of the change differences; and searches the string for a set of disallowed commands for checking for assertions in the given pull request which is attempting only to change code with a fake test that always passes the code in connection with testing the application. When such a command is found, comments back to the given pull request indicating that the given pull request contains the fake test.