docker-diff 0.0.1__py3-none-any.whl

docker_diff-0.0.1.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: docker-diff
+Version: 0.0.1
+Summary: Docker Image Comparison Database Manager
+License: This is free and unencumbered software released into the public domain.
+        
+        Anyone is free to copy, modify, publish, use, compile, sell, or
+        distribute this software, either in source code form or as a compiled
+        binary, for any purpose, commercial or non-commercial, and by any
+        means.
+        
+        In jurisdictions that recognize copyright laws, the author or authors
+        of this software dedicate any and all copyright interest in the
+        software to the public domain. We make this dedication for the benefit
+        of the public at large and to the detriment of our heirs and
+        successors. We intend this dedication to be an overt act of
+        relinquishment in perpetuity of all present and future rights to this
+        software under copyright law.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+        IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+        OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+        ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+        OTHER DEALINGS IN THE SOFTWARE.
+        
+        For more information, please refer to <https://unlicense.org>
+        
+Project-URL: Repository, https://github.com/eapolinario/docker-diff
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

docker_diff-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+docker_diff.py,sha256=_Jt20fhQqZQGac-PacGyV9IU10FXNoCrc6lqlZe4Gps,15516
+docker_diff-0.0.1.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+docker_diff-0.0.1.dist-info/METADATA,sha256=XnO5IBtAKuZq0xQ8C45jYB445OD91_xdzrTnsfh0Ktc,1654
+docker_diff-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+docker_diff-0.0.1.dist-info/entry_points.txt,sha256=Hknxh2UZBgBH5Lwe55BK5Gh813R1qHZSPIYQ9dzKQXk,49
+docker_diff-0.0.1.dist-info/top_level.txt,sha256=HSDBG4y8znoDTP5jcUCH2gZZ-qiZW0_6AsIeXry71Ew,12
+docker_diff-0.0.1.dist-info/RECORD,,

docker_diff-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

docker_diff-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docker-diff = docker_diff:main

docker_diff-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

docker_diff-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+docker_diff

docker_diff.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python3
+"""
+Docker Image Comparison Database Manager
+Provides functions to store and query Docker image file comparison results in SQLite
+"""
+
+import sqlite3
+import json
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple
+
+class DockerImageDB:
+    def __init__(self, db_path: str = "docker_images.db"):
+        self.db_path = db_path
+        self.init_database()
+    
+    def init_database(self):
+        """Initialize the database with schema"""
+        with sqlite3.connect(self.db_path) as conn:
+            # Read and execute schema
+            schema_path = Path(__file__).parent / "schema.sql"
+            with open(schema_path) as f:
+                conn.executescript(f.read())
+    
+    def add_image(self, name: str, digest: str = None, size_bytes: int = None) -> int:
+        """Add an image to the database, return image_id"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT OR IGNORE INTO images (name, digest, size_bytes) 
+                VALUES (?, ?, ?)
+            """, (name, digest, size_bytes))
+            
+            # Get the image ID
+            cursor.execute("SELECT id FROM images WHERE name = ?", (name,))
+            return cursor.fetchone()[0]
+    
+    def add_files_for_image(self, image_id: int, files: List[Dict]):
+        """Add file listings for an image"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Clear existing files for this image
+            cursor.execute("DELETE FROM files WHERE image_id = ?", (image_id,))
+            
+            # Insert new files
+            file_data = []
+            for file_info in files:
+                file_data.append((
+                    image_id,
+                    file_info['path'],
+                    file_info.get('size', 0),
+                    file_info.get('mode'),
+                    file_info.get('mtime'),
+                    file_info.get('type', 'file'),
+                    file_info.get('checksum')
+                ))
+            
+            cursor.executemany("""
+                INSERT INTO files 
+                (image_id, file_path, file_size, file_mode, modified_time, file_type, checksum)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, file_data)
+    
+    def scan_image(self, image_name: str) -> int:
+        """Scan a Docker image and store its files"""
+        print(f"Scanning {image_name}...")
+        
+        # Add image to database
+        image_id = self.add_image(image_name)
+        
+        # Get file listing using docker run
+        try:
+            result = subprocess.run([
+                'docker', 'run', '--rm', image_name, 
+                'find', '/', '-type', 'f', '-exec', 'stat', '-c', '%n|%s|%Y', '{}', ';'
+            ], capture_output=True, text=True)
+            
+            files = []
+            for line in result.stdout.strip().split('\n'):
+                if '|' in line:
+                    parts = line.split('|')
+                    if len(parts) >= 3:
+                        files.append({
+                            'path': parts[0],
+                            'size': int(parts[1]) if parts[1].isdigit() else 0,
+                            'mtime': int(parts[2]) if parts[2].isdigit() else None
+                        })
+            
+            self.add_files_for_image(image_id, files)
+            print(f"  Stored {len(files)} files for {image_name}")
+            return image_id
+            
+        except subprocess.SubprocessError as e:
+            print(f"Error scanning {image_name}: {e}")
+            return image_id
+    
+    def create_comparison(self, name: str, description: str = None) -> int:
+        """Create a new comparison session"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO comparisons (name, description) 
+                VALUES (?, ?)
+            """, (name, description))
+            return cursor.lastrowid
+    
+    def add_images_to_comparison(self, comparison_id: int, image_ids: List[int]):
+        """Add images to a comparison"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            for image_id in image_ids:
+                cursor.execute("""
+                    INSERT OR IGNORE INTO comparison_images (comparison_id, image_id)
+                    VALUES (?, ?)
+                """, (comparison_id, image_id))
+    
+    def compare_images(self, image_names: List[str], comparison_name: str = None) -> int:
+        """Compare multiple images and store results"""
+        if not comparison_name:
+            comparison_name = f"Comparison_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        # Scan all images
+        image_ids = []
+        for image_name in image_names:
+            image_id = self.scan_image(image_name)
+            image_ids.append(image_id)
+        
+        # Create comparison
+        comparison_id = self.create_comparison(
+            comparison_name, 
+            f"Comparing: {', '.join(image_names)}"
+        )
+        
+        # Add images to comparison
+        self.add_images_to_comparison(comparison_id, image_ids)
+        
+        # Generate file differences
+        self._generate_file_differences(comparison_id)
+        
+        return comparison_id
+    
+    def _generate_file_differences(self, comparison_id: int):
+        """Generate file difference records for a comparison"""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                INSERT INTO file_differences 
+                (comparison_id, file_path, difference_type, source_image_id, target_image_id, old_size, new_size, size_change)
+                SELECT 
+                    ? as comparison_id,
+                    f1.file_path,
+                    CASE 
+                        WHEN f2.file_path IS NULL THEN 'only_in_first'
+                        WHEN f1.file_size != f2.file_size THEN 'changed'
+                        ELSE 'common'
+                    END as difference_type,
+                    f1.image_id as source_image_id,
+                    f2.image_id as target_image_id,
+                    f1.file_size as old_size,
+                    f2.file_size as new_size,
+                    COALESCE(f2.file_size - f1.file_size, -f1.file_size) as size_change
+                FROM files f1
+                JOIN comparison_images ci1 ON f1.image_id = ci1.image_id
+                LEFT JOIN files f2 ON f1.file_path = f2.file_path 
+                    AND f2.image_id IN (
+                        SELECT ci2.image_id FROM comparison_images ci2 
+                        WHERE ci2.comparison_id = ? AND ci2.image_id != f1.image_id
+                    )
+                WHERE ci1.comparison_id = ?
+            """, (comparison_id, comparison_id, comparison_id))
+    
+    def get_comparison_summary(self, comparison_id: int) -> Dict:
+        """Get summary statistics for a comparison"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Get basic info
+            cursor.execute("""
+                SELECT c.name, c.description, c.created_at,
+                       GROUP_CONCAT(i.name, ', ') as images
+                FROM comparisons c
+                JOIN comparison_images ci ON c.id = ci.comparison_id
+                JOIN images i ON ci.image_id = i.id
+                WHERE c.id = ?
+                GROUP BY c.id
+            """, (comparison_id,))
+            
+            basic_info = cursor.fetchone()
+            if not basic_info:
+                return {}
+            
+            # Get difference counts
+            cursor.execute("""
+                SELECT difference_type, COUNT(*) as count
+                FROM file_differences
+                WHERE comparison_id = ?
+                GROUP BY difference_type
+            """, (comparison_id,))
+            
+            diff_counts = dict(cursor.fetchall())
+            
+            return {
+                'name': basic_info[0],
+                'description': basic_info[1],
+                'created_at': basic_info[2],
+                'images': basic_info[3].split(', '),
+                'differences': diff_counts,
+                'total_differences': sum(diff_counts.values())
+            }
+    
+    def query_unique_files(self, comparison_id: int) -> List[Tuple]:
+        """Get files unique to each image in comparison"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT i.name as image_name, f.file_path, f.file_size
+                FROM unique_files uf
+                JOIN comparisons c ON uf.comparison_name = c.name
+                JOIN images i ON uf.image_name = i.name
+                JOIN files f ON i.id = f.image_id AND uf.file_path = f.file_path
+                WHERE c.id = ?
+                ORDER BY i.name, f.file_size DESC
+            """, (comparison_id,))
+            return cursor.fetchall()
+
+
+def print_comparison_summary(db: DockerImageDB, comparison_id: int):
+    """Print detailed comparison summary"""
+    summary = db.get_comparison_summary(comparison_id)
+    if not summary:
+        print(f"No comparison found with ID {comparison_id}")
+        return
+    
+    print(f"\n{'='*60}")
+    print(f"COMPARISON SUMMARY")
+    print(f"{'='*60}")
+    print(f"Name: {summary['name']}")
+    print(f"Description: {summary.get('description', 'N/A')}")
+    print(f"Created: {summary['created_at']}")
+    print(f"Images: {', '.join(summary['images'])}")
+    print(f"\nDifference Summary:")
+    
+    diff_counts = summary.get('differences', {})
+    total = summary.get('total_differences', 0)
+    
+    if total == 0:
+        print("  No differences found")
+    else:
+        for diff_type, count in diff_counts.items():
+            percentage = (count / total) * 100
+            print(f"  {diff_type.capitalize()}: {count} ({percentage:.1f}%)")
+        print(f"  Total: {total}")
+
+
+def list_comparisons(db: DockerImageDB):
+    """List all comparisons in the database"""
+    with sqlite3.connect(db.db_path) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            SELECT 
+                c.id,
+                c.name,
+                c.created_at,
+                COUNT(DISTINCT ci.image_id) as image_count,
+                GROUP_CONCAT(i.name, ', ') as images
+            FROM comparisons c
+            JOIN comparison_images ci ON c.id = ci.comparison_id
+            JOIN images i ON ci.image_id = i.id
+            GROUP BY c.id
+            ORDER BY c.created_at DESC
+        """)
+        
+        comparisons = cursor.fetchall()
+        
+        if not comparisons:
+            print("No comparisons found in database.")
+            return
+        
+        print(f"\n{'ID':<4} {'Name':<25} {'Images':<8} {'Date':<20} {'Image Names'}")
+        print("-" * 80)
+        
+        for comp_id, name, created, img_count, img_names in comparisons:
+            # Truncate long image names
+            if len(img_names) > 35:
+                img_names = img_names[:32] + "..."
+            print(f"{comp_id:<4} {name[:24]:<25} {img_count:<8} {created[:19]:<20} {img_names}")
+
+
+def list_images(db: DockerImageDB):
+    """List all images in the database"""
+    with sqlite3.connect(db.db_path) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            SELECT 
+                i.id,
+                i.name,
+                i.scanned_at,
+                COUNT(f.id) as file_count,
+                COALESCE(SUM(f.file_size), 0) as total_size
+            FROM images i
+            LEFT JOIN files f ON i.id = f.image_id
+            GROUP BY i.id
+            ORDER BY i.scanned_at DESC
+        """)
+        
+        images = cursor.fetchall()
+        
+        if not images:
+            print("No images found in database.")
+            return
+        
+        print(f"\n{'ID':<4} {'Image Name':<30} {'Files':<8} {'Size (MB)':<12} {'Scanned'}")
+        print("-" * 80)
+        
+        for img_id, name, scanned, file_count, total_size in images:
+            size_mb = total_size / (1024 * 1024) if total_size else 0
+            print(f"{img_id:<4} {name[:29]:<30} {file_count:<8} {size_mb:<12.2f} {scanned[:19] if scanned else 'Never'}")
+
+
+def show_unique_files(db: DockerImageDB, comparison_id: int, limit: int = 20):
+    """Show files unique to each image in a comparison"""
+    unique_files = db.query_unique_files(comparison_id)
+    
+    if not unique_files:
+        print(f"No unique files found for comparison {comparison_id}")
+        return
+    
+    print(f"\nUnique Files (showing first {limit}):")
+    print(f"{'Image':<25} {'Size (KB)':<12} {'File Path'}")
+    print("-" * 80)
+    
+    for i, (image_name, file_path, file_size) in enumerate(unique_files[:limit]):
+        size_kb = file_size / 1024 if file_size else 0
+        print(f"{image_name[:24]:<25} {size_kb:<12.2f} {file_path}")
+
+
+# ---- CLI entry point ----
+
+def _cmd_scan(db: DockerImageDB, args):
+    for image in args.images:
+        db.scan_image(image)
+
+def _cmd_compare(db: DockerImageDB, args):
+    comparison_id = db.compare_images(args.images, args.name)
+    print_comparison_summary(db, comparison_id)
+
+def _cmd_list_images(db: DockerImageDB, args):
+    list_images(db)
+
+def _cmd_list_comparisons(db: DockerImageDB, args):
+    list_comparisons(db)
+
+def _cmd_summary(db: DockerImageDB, args):
+    print_comparison_summary(db, args.id)
+
+def _cmd_unique(db: DockerImageDB, args):
+    show_unique_files(db, args.id, args.limit)
+
+
+def main():
+    """docker-diff command line interface"""
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="docker-diff", description="Docker image file comparison and database manager")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_scan = sub.add_parser("scan", help="Scan one or more images and store file listings")
+    p_scan.add_argument("images", nargs="+", help="Docker image names (e.g., ubuntu:22.04)")
+    p_scan.set_defaults(func=_cmd_scan)
+
+    p_compare = sub.add_parser("compare", help="Compare images and store results")
+    p_compare.add_argument("images", nargs="+", help="Docker image names to compare")
+    p_compare.add_argument("--name", help="Optional comparison name")
+    p_compare.set_defaults(func=_cmd_compare)
+
+    p_list = sub.add_parser("list", help="List images or comparisons")
+    sub_list = p_list.add_subparsers(dest="what", required=True)
+
+    p_list_images = sub_list.add_parser("images", help="List scanned images")
+    p_list_images.set_defaults(func=_cmd_list_images)
+
+    p_list_comparisons = sub_list.add_parser("comparisons", help="List comparisons")
+    p_list_comparisons.set_defaults(func=_cmd_list_comparisons)
+
+    p_summary = sub.add_parser("summary", help="Show summary for a comparison")
+    p_summary.add_argument("id", type=int, help="Comparison ID")
+    p_summary.set_defaults(func=_cmd_summary)
+
+    p_unique = sub.add_parser("unique", help="Show files unique to each image in a comparison")
+    p_unique.add_argument("id", type=int, help="Comparison ID")
+    p_unique.add_argument("--limit", type=int, default=20, help="Max rows to display")
+    p_unique.set_defaults(func=_cmd_unique)
+
+    args = parser.parse_args()
+    db = DockerImageDB()
+    args.func(db, args)
+
+
+if __name__ == "__main__":
+    main()