Source Code Commit Record Synchronization via Partial Data Storage
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Synchronization disruptions between issue tracking systems (ITS) and source code management systems (SCM) often occur due to network issues, service outages, or bugs, leading to fragmented data and inefficient resource usage, as existing methods struggle to handle large data streams effectively.
Innovation Solution
The implementation of a computer-implemented method that efficiently stores and analyzes source code modification history data by generating and submitting database queries to convert partial commit records into full commit records, allowing for robust data synchronization with reduced CPU cycles and memory usage, and providing a failsafe approach to complete large-scale synchronization procedures.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional synchronization methods are used to synchronize data between ITS and SCM systems, then data synchronization can be achieved, but the process consumes excessive CPU cycles and memory resources, and is prone to disruptions
Solution Approach 1:
The patent segments the commit record data into different types (full commit records and partial commit records) and processes them through different pathways. Full commit records are processed immediately while partial commit records are handled through a deferred processing mechanism using database queries, reducing the immediate computational burden and memory usage during synchronization.
Solution Approach 2:
The patent performs preliminary actions by storing metadata about commit records (such as commit hashes, parent commit references, and file change summaries) before actual data synchronization. This allows the system to prepare and organize data structures in advance, reducing the computational intensity during the actual synchronization process.
2Productivity
If traditional synchronization methods are used to handle large data streams, then data can be synchronized, but disruptions occur leading to fragmented data and wasted compute resources
Solution Approach 1:
The patent implements a feedback mechanism where the system continuously monitors the synchronization process, detects disruptions, and automatically adjusts its operation. When disruptions are detected, the system uses the stored metadata and commit record structure to identify where synchronization broke and resumes from that point, preventing data fragmentation and avoiding wasteful restarts.
Solution Approach 2:
The patent introduces an intermediary layer of metadata storage and commit record indexing that acts as a buffer between the ITS and SCM systems. This intermediary structure allows the system to detect and handle synchronization disruptions without losing data integrity, as the metadata provides a roadmap for recovering and completing the synchronization process.
3Loss of information
If complete commit records are stored for all source code modifications, then data completeness is maintained, but storage requirements and processing overhead increase significantly
Solution Approach 1:
The patent applies local quality by storing different types of information at different levels of detail. Full commit records with complete data are stored for commits that are immediately processed, while partial commit records with summarized metadata are stored for deferred processing. This differentiated storage approach maintains data completeness where needed while reducing overall storage requirements.
Solution Approach 2:
The patent uses partial action by storing and processing only the essential metadata of commit records (such as commit hashes, parent references, and file change summaries) rather than complete commit data for all records. This partial storage approach reduces storage requirements while maintaining sufficient information for synchronization and recovery purposes.
Data Source
AI summary
In one embodiment, a computer-implemented method comprises receiving, at a server computer, a plurality of commit records of a source code management system (SCM), wherein a first commit record of the plurality of commit records includes a first parent commit identifier (ID) that identifies a parent commit record of the first commit record; storing, in one or more data repositories, a full commit record for each commit record of the plurality of commit records; in response to determining that the first commit record includes a parent commit ID, storing, in the one or more data repositories, a first partial commit record for the first commit record, wherein the first partial commit record comprises a partial commit record that is identified by the first parent commit ID; generating and submitting a database query to a digital data repository associated with the SCM, based on determining that a partial commit record is stored in the one or more digital repositories, and receiving first partial commit update data for the first partial commit record; updating, based on the first partial commit update data, one or more fields of the first partial commit record to convert the first partial commit record into an updated commit record, wherein the updated commit record comprises a full commit record.