#!/usr/bin/env python3
# performance_profiler.py

import subprocess
import json
import time
import matplotlib.pyplot as plt
from collections import defaultdict
import numpy as np

class ContainerProfiler:
    def __init__(self, container_name):
        self.container = container_name
        self.metrics = defaultdict(list)
        self.timestamps = []
    
    def collect_metrics(self, duration=60, interval=1):
        """メトリクス収集"""
        print(f"Collecting metrics for {duration} seconds...")
        
        start_time = time.time()
        while time.time() - start_time < duration:
            # CPU使用率取得
            cpu = self._get_cpu_usage()
            
            # メモリ使用量取得
            memory = self._get_memory_usage()
            
            # I/O統計取得
            io_stats = self._get_io_stats()
            
            # ネットワーク統計取得
            net_stats = self._get_network_stats()
            
            # 記録
            self.timestamps.append(time.time() - start_time)
            self.metrics['cpu'].append(cpu)
            self.metrics['memory'].append(memory)
            self.metrics['io_read'].append(io_stats['read'])
            self.metrics['io_write'].append(io_stats['write'])
            self.metrics['net_rx'].append(net_stats['rx'])
            self.metrics['net_tx'].append(net_stats['tx'])
            
            time.sleep(interval)
    
    def _get_cpu_usage(self):
        """CPU使用率取得"""
        try:
            result = subprocess.run(
                ['podman', 'stats', '--no-stream', '--format', 'json', self.container],
                capture_output=True, text=True
            )
            stats = json.loads(result.stdout)[0]
            return float(stats['CPUPerc'].rstrip('%'))
        except:
            return 0.0
    
    def _get_memory_usage(self):
        """メモリ使用量取得（MB）"""
        try:
            result = subprocess.run(
                ['podman', 'stats', '--no-stream', '--format', 'json', self.container],
                capture_output=True, text=True
            )
            stats = json.loads(result.stdout)[0]
            mem_str = stats['MemUsage'].split('/')[0]
            
            # 単位変換
            if 'GiB' in mem_str:
                return float(mem_str.replace('GiB', '')) * 1024
            elif 'MiB' in mem_str:
                return float(mem_str.replace('MiB', ''))
            else:
                return 0.0
        except:
            return 0.0
    
    def _get_io_stats(self):
        """I/O統計取得"""
        # 実装はプラットフォーム依存
        return {'read': 0, 'write': 0}
    
    def _get_network_stats(self):
        """ネットワーク統計取得"""
        # 実装はプラットフォーム依存
        return {'rx': 0, 'tx': 0}
    
    def analyze(self):
        """分析結果生成"""
        print("\n=== Performance Analysis ===")
        
        # CPU分析
        cpu_data = self.metrics['cpu']
        print(f"CPU Usage:")
        print(f"  Average: {np.mean(cpu_data):.2f}%")
        print(f"  Max: {np.max(cpu_data):.2f}%")
        print(f"  Std Dev: {np.std(cpu_data):.2f}%")
        
        # メモリ分析
        mem_data = self.metrics['memory']
        print(f"\nMemory Usage:")
        print(f"  Average: {np.mean(mem_data):.2f} MB")
        print(f"  Max: {np.max(mem_data):.2f} MB")
        
        # 異常検出
        self._detect_anomalies()
    
    def _detect_anomalies(self):
        """異常検出"""
        print("\n=== Anomaly Detection ===")
        
        # CPU スパイク検出
        cpu_data = np.array(self.metrics['cpu'])
        cpu_mean = np.mean(cpu_data)
        cpu_std = np.std(cpu_data)
        spikes = np.where(cpu_data > cpu_mean + 2 * cpu_std)[0]
        
        if len(spikes) > 0:
            print(f"CPU spikes detected at timestamps: {[self.timestamps[i] for i in spikes]}")
        
        # メモリリーク検出（単純な線形回帰）
        mem_data = np.array(self.metrics['memory'])
        if len(mem_data) > 10:
            slope = np.polyfit(self.timestamps, mem_data, 1)[0]
            if slope > 0.1:  # MB/秒
                print(f"Possible memory leak detected: {slope:.2f} MB/sec increase")
    
    def plot_results(self):
        """結果のプロット"""
        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 8))
        
        # CPU使用率
        ax1.plot(self.timestamps, self.metrics['cpu'])
        ax1.set_title('CPU Usage')
        ax1.set_ylabel('CPU %')
        ax1.grid(True)
        
        # メモリ使用量
        ax2.plot(self.timestamps, self.metrics['memory'])
        ax2.set_title('Memory Usage')
        ax2.set_ylabel('Memory (MB)')
        ax2.grid(True)
        
        # その他のメトリクス
        # ...
        
        plt.tight_layout()
        plt.savefig('performance_profile.png')
        print(f"\nPerformance graph saved to performance_profile.png")

if __name__ == "__main__":
    import sys
    
    if len(sys.argv) < 2:
        print("Usage: python performance_profiler.py <container_name> [duration]")
        sys.exit(1)
    
    container = sys.argv[1]
    duration = int(sys.argv[2]) if len(sys.argv) > 2 else 60
    
    profiler = ContainerProfiler(container)
    profiler.collect_metrics(duration)
    profiler.analyze()
    profiler.plot_results()

#!/usr/bin/env python3
# security_policy_checker.py

import subprocess
import json
import yaml
from datetime import datetime

class SecurityPolicyChecker:
    def __init__(self, policy_file):
        with open(policy_file, 'r') as f:
            self.policy = yaml.safe_load(f)
        
        self.violations = []
    
    def check_all_containers(self):
        """全コンテナのポリシーチェック"""
        containers = self._get_running_containers()
        
        for container in containers:
            self.check_container(container)
        
        return self.violations
    
    def check_container(self, container_id):
        """個別コンテナのチェック"""
        inspect_data = self._inspect_container(container_id)
        
        if not inspect_data:
            return
        
        container_name = inspect_data['Name'].lstrip('/')
        
        # 各ポリシーチェック
        self._check_privileged_mode(container_name, inspect_data)
        self._check_capabilities(container_name, inspect_data)
        self._check_user_namespace(container_name, inspect_data)
        self._check_resource_limits(container_name, inspect_data)
        self._check_network_exposure(container_name, inspect_data)
        self._check_volume_mounts(container_name, inspect_data)
    
    def _check_privileged_mode(self, name, data):
        """特権モードチェック"""
        if data['HostConfig']['Privileged']:
            if not self.policy.get('allow_privileged', False):
                self.violations.append({
                    'container': name,
                    'type': 'privileged_mode',
                    'severity': 'critical',
                    'message': 'Container is running in privileged mode'
                })
    
    def _check_capabilities(self, name, data):
        """ケーパビリティチェック"""
        caps = data.get('EffectiveCaps', [])
        forbidden_caps = self.policy.get('forbidden_capabilities', [])
        
        for cap in caps:
            if cap in forbidden_caps:
                self.violations.append({
                    'container': name,
                    'type': 'forbidden_capability',
                    'severity': 'high',
                    'message': f'Container has forbidden capability: {cap}'
                })
    
    def _check_resource_limits(self, name, data):
        """リソース制限チェック"""
        # メモリ制限
        memory_limit = data['HostConfig'].get('Memory', 0)
        if memory_limit == 0:
            if self.policy.get('require_memory_limit', True):
                self.violations.append({
                    'container': name,
                    'type': 'no_memory_limit',
                    'severity': 'medium',
                    'message': 'Container has no memory limit'
                })
        
        # CPU制限
        cpu_quota = data['HostConfig'].get('CpuQuota', 0)
        if cpu_quota == 0:
            if self.policy.get('require_cpu_limit', True):
                self.violations.append({
                    'container': name,
                    'type': 'no_cpu_limit',
                    'severity': 'medium',
                    'message': 'Container has no CPU limit'
                })
    
    def _check_network_exposure(self, name, data):
        """ネットワーク露出チェック"""
        ports = data['NetworkSettings'].get('Ports', {})
        
        for port, bindings in ports.items():
            if bindings:
                for binding in bindings:
                    if binding['HostIp'] == '0.0.0.0':
                        self.violations.append({
                            'container': name,
                            'type': 'exposed_port',
                            'severity': 'medium',
                            'message': f'Port {port} is exposed to all interfaces'
                        })
    
    def generate_report(self):
        """セキュリティレポート生成"""
        report = {
            'timestamp': datetime.now().isoformat(),
            'total_violations': len(self.violations),
            'violations_by_severity': {
                'critical': len([v for v in self.violations if v['severity'] == 'critical']),
                'high': len([v for v in self.violations if v['severity'] == 'high']),
                'medium': len([v for v in self.violations if v['severity'] == 'medium']),
                'low': len([v for v in self.violations if v['severity'] == 'low'])
            },
            'violations': self.violations
        }
        
        return report
    
    def _get_running_containers(self):
        """実行中のコンテナ一覧取得"""
        result = subprocess.run(
            ['podman', 'ps', '-q'],
            capture_output=True,
            text=True
        )
        return result.stdout.strip().split('\n') if result.stdout else []
    
    def _inspect_container(self, container_id):
        """コンテナ詳細情報取得"""
        result = subprocess.run(
            ['podman', 'inspect', container_id],
            capture_output=True,
            text=True
        )
        
        if result.returncode == 0:
            return json.loads(result.stdout)[0]
        return None

# ポリシーファイル例
policy_example = {
    'allow_privileged': False,
    'forbidden_capabilities': ['SYS_ADMIN', 'SYS_MODULE', 'SYS_RAWIO'],
    'require_memory_limit': True,
    'require_cpu_limit': True,
    'require_user_namespace': True,
    'forbidden_mounts': ['/etc', '/sys', '/proc'],
    'max_memory': '4G',
    'max_cpu': 4
}

#!/usr/bin/env python3
# ai_troubleshooter.py

import json
import subprocess
from datetime import datetime

class AITroubleshooter:
    """AI支援トラブルシューティングシステム（概念実装）"""
    
    def __init__(self):
        self.knowledge_base = self._load_knowledge_base()
        self.diagnostic_history = []
    
    def diagnose_issue(self, symptoms):
        """症状から問題を診断"""
        
        # 症状の分析
        analyzed_symptoms = self._analyze_symptoms(symptoms)
        
        # 類似の問題を検索
        similar_issues = self._search_similar_issues(analyzed_symptoms)
        
        # 診断結果の生成
        diagnosis = {
            'timestamp': datetime.now().isoformat(),
            'symptoms': symptoms,
            'probable_causes': [],
            'recommended_actions': [],
            'confidence': 0.0
        }
        
        # 原因の推定
        for issue in similar_issues:
            cause = {
                'description': issue['cause'],
                'probability': issue['similarity_score'],
                'evidence': issue['matching_symptoms']
            }
            diagnosis['probable_causes'].append(cause)
        
        # 推奨アクションの生成
        for issue in similar_issues[:3]:  # 上位3つ
            for action in issue['solutions']:
                diagnosis['recommended_actions'].append({
                    'action': action,
                    'expected_outcome': issue['outcome'],
                    'risk_level': self._assess_risk(action)
                })
        
        # 信頼度の計算
        if similar_issues:
            diagnosis['confidence'] = similar_issues[0]['similarity_score']
        
        self.diagnostic_history.append(diagnosis)
        return diagnosis
    
    def _analyze_symptoms(self, symptoms):
        """症状の分析と特徴抽出"""
        features = {
            'error_codes': [],
            'keywords': [],
            'metrics': {},
            'patterns': []
        }
        
        # エラーコード抽出
        import re
        error_pattern = r'(error|err|failed|failure):\s*(\d+|\w+)'
        matches = re.findall(error_pattern, symptoms, re.IGNORECASE)
        features['error_codes'] = [m[1] for m in matches]
        
        # キーワード抽出
        keywords = ['permission', 'network', 'memory', 'cpu', 'disk', 'timeout']
        for keyword in keywords:
            if keyword in symptoms.lower():
                features['keywords'].append(keyword)
        
        return features
    
    def _search_similar_issues(self, features):
        """類似問題の検索"""
        similar_issues = []
        
        for issue in self.knowledge_base:
            similarity = self._calculate_similarity(features, issue['features'])
            
            if similarity > 0.5:  # 閾値
                similar_issues.append({
                    'cause': issue['cause'],
                    'solutions': issue['solutions'],
                    'outcome': issue['outcome'],
                    'similarity_score': similarity,
                    'matching_symptoms': issue['symptoms']
                })
        
        # スコアでソート
        similar_issues.sort(key=lambda x: x['similarity_score'], reverse=True)
        return similar_issues
    
    def _calculate_similarity(self, features1, features2):
        """類似度計算（簡易版）"""
        score = 0.0
        
        # エラーコードの一致
        common_errors = set(features1.get('error_codes', [])) & set(features2.get('error_codes', []))
        if common_errors:
            score += 0.5
        
        # キーワードの一致
        common_keywords = set(features1.get('keywords', [])) & set(features2.get('keywords', []))
        score += len(common_keywords) * 0.1
        
        return min(score, 1.0)
    
    def _assess_risk(self, action):
        """アクションのリスク評価"""
        high_risk_keywords = ['rm', 'delete', 'prune', 'kill', 'stop']
        medium_risk_keywords = ['restart', 'reload', 'update']
        
        action_lower = action.lower()
        
        if any(keyword in action_lower for keyword in high_risk_keywords):
            return 'high'
        elif any(keyword in action_lower for keyword in medium_risk_keywords):
            return 'medium'
        else:
            return 'low'
    
    def _load_knowledge_base(self):
        """知識ベースのロード"""
        # 実際の実装では、データベースやファイルから読み込む
        return [
            {
                'id': 1,
                'symptoms': 'Container exits with code 125',
                'features': {
                    'error_codes': ['125'],
                    'keywords': ['exit', 'error']
                },
                'cause': 'Podman unable to run the container',
                'solutions': [
                    'Check if the image exists: podman images',
                    'Verify the command syntax',
                    'Check for typos in image name or tag'
                ],
                'outcome': 'Container runs successfully'
            },
            {
                'id': 2,
                'symptoms': 'Permission denied when mounting volume',
                'features': {
                    'keywords': ['permission', 'volume', 'mount'],
                    'error_codes': []
                },
                'cause': 'SELinux context mismatch',
                'solutions': [
                    'Add :Z or :z to volume mount',
                    'Check SELinux status: getenforce',
                    'Verify file ownership with ls -laZ'
                ],
                'outcome': 'Volume mounts successfully'
            }
            # ... 他の問題パターン
        ]

# 使用例
if __name__ == "__main__":
    troubleshooter = AITroubleshooter()
    
    # 症状の入力
    symptoms = """
    Container myapp exits immediately with code 125.
    Error message: Error: error creating container storage:
    """
    
    # 診断実行
    diagnosis = troubleshooter.diagnose_issue(symptoms)
    
    # 結果表示
    print(json.dumps(diagnosis, indent=2))