【2025年7月最新】マイクラ CurseForge Modpack 自動更新システム構築ガイド

# CurseForge API 基本設定
API_BASE_URL = “https://api.curseforge.com”
API_VERSION = “v1”
HEADERS = {
“Accept”: “application/json”,
“x-api-key”: “YOUR_API_KEY_HERE”
}

import os
import requests
from typing import Dict, Anyclass CurseForgeAPI:
def __init__(self):
self.api_key = os.getenv(“CURSEFORGE_API_KEY”)
self.base_url = “https://api.curseforge.com/v1”
self.headers = {
“Accept”: “application/json”,
“x-api-key”: self.api_key
}

def test_connection(self) -> bool:
“””API接続テスト”””
try:
response = requests.get(
f”{self.base_url}/games”,
headers=self.headers
)
return response.status_code == 200
except Exception as e:
print(f”接続テストエラー: {e}”)
return False

#!/usr/bin/env python3
“””
CurseForge Modpack自動同期スクリプト
2025年7月最新版
“””import json
import os
import shutil
import hashlib
import requests
from datetime import datetime
from pathlib import Path
from typing import List, Dict, Optional

class ModpackSyncManager:
def __init__(self, config_path: str):
self.config = self.load_config(config_path)
self.api = CurseForgeAPI()
self.sync_log = []

def load_config(self, config_path: str) -> Dict:
“””設定ファイルの読み込み”””
with open(config_path, ‘r’, encoding=’utf-8′) as f:
return json.load(f)

def get_modpack_info(self, modpack_id: int) -> Dict:
“””Modpack情報の取得”””
url = f”{self.api.base_url}/mods/{modpack_id}”
response = requests.get(url, headers=self.api.headers)

if response.status_code == 200:
return response.json()
else:
raise Exception(f”Modpack情報の取得に失敗: {response.status_code}”)

def check_for_updates(self) -> List[Dict]:
“””更新確認処理”””
updates = []

for modpack in self.config[‘modpacks’]:
current_info = self.get_modpack_info(modpack[‘id’])
latest_file = current_info[‘data’][‘latestFiles’][0]

if latest_file[‘id’] != modpack[‘current_file_id’]:
updates.append({
‘modpack’: modpack,
‘latest_file’: latest_file,
‘current_file_id’: modpack[‘current_file_id’]
})

return updates

def download_modpack(self, file_info: Dict, download_path: str) -> bool:
“””Modpackのダウンロード”””
try:
download_url = file_info[‘downloadUrl’]

with requests.get(download_url, stream=True) as response:
response.raise_for_status()

with open(download_path, ‘wb’) as f:
for chunk in response.iter_content(chunk_size=8192):
f.write(chunk)

return True
except Exception as e:
print(f”ダウンロードエラー: {e}”)
return False

def sync_modpack(self, update_info: Dict) -> bool:
“””Modpackの同期処理”””
modpack = update_info[‘modpack’]
latest_file = update_info[‘latest_file’]

# バックアップの作成
self.create_backup(modpack[‘name’])

# 新しいファイルのダウンロード
download_path = f”/tmp/{latest_file[‘fileName’]}”

if self.download_modpack(latest_file, download_path):
# 展開処理
self.extract_modpack(download_path, modpack[‘install_path’])

# 設定ファイルの更新
self.update_modpack_config(modpack, latest_file[‘id’])

self.sync_log.append({
‘modpack’: modpack[‘name’],
‘version’: latest_file[‘displayName’],
‘timestamp’: datetime.now().isoformat(),
‘status’: ‘success’
})

return True
else:
self.sync_log.append({
‘modpack’: modpack[‘name’],
‘timestamp’: datetime.now().isoformat(),
‘status’: ‘failed’
})

return False

# crontab設定例
# 毎日午前3時にModpack同期を実行
0 3 * * * /usr/bin/python3 /path/to/modpack_sync.py# Systemdタイマー設定例（/etc/systemd/system/modpack-sync.timer）
[Unit]
Description=Modpack Sync Timer
Requires=modpack-sync.service

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target

import hashlib
import os
from typing import Dict, List, Setclass DiffPatchManager:
def __init__(self, base_path: str):
self.base_path = base_path
self.hash_cache = {}

def calculate_file_hash(self, file_path: str) -> str:
“””ファイルのSHA-256ハッシュを計算”””
sha256_hash = hashlib.sha256()

with open(file_path, “rb”) as f:
for chunk in iter(lambda: f.read(4096), b””):
sha256_hash.update(chunk)

return sha256_hash.hexdigest()

def build_file_index(self, directory: str) -> Dict[str, str]:
“””ディレクトリのファイルインデックスを作成”””
file_index = {}

for root, dirs, files in os.walk(directory):
for file in files:
file_path = os.path.join(root, file)
relative_path = os.path.relpath(file_path, directory)
file_hash = self.calculate_file_hash(file_path)

file_index[relative_path] = file_hash

return file_index

def compare_versions(self, old_index: Dict[str, str],
new_index: Dict[str, str]) -> Dict[str, List[str]]:
“””バージョン間の差分を検出”””
old_files = set(old_index.keys())
new_files = set(new_index.keys())

added_files = new_files – old_files
removed_files = old_files – new_files
common_files = old_files & new_files

modified_files = [
file for file in common_files
if old_index[file] != new_index[file]
]

return {
‘added’: list(added_files),
‘removed’: list(removed_files),
‘modified’: modified_files
}

def create_patch(self, old_version: str, new_version: str) -> Dict:
“””パッチファイルの作成”””
old_index = self.build_file_index(old_version)
new_index = self.build_file_index(new_version)

diff = self.compare_versions(old_index, new_index)

patch_data = {
‘version’: ‘1.0’,
‘timestamp’: datetime.now().isoformat(),
‘changes’: diff,
‘checksums’: {
‘old_version’: self.calculate_directory_hash(old_version),
‘new_version’: self.calculate_directory_hash(new_version)
}
}

return patch_data

def apply_patch(self, patch_data: Dict, target_directory: str) -> bool:
“””パッチの適用”””
try:
changes = patch_data[‘changes’]

# 削除されたファイルの処理
for file_path in changes[‘removed’]:
full_path = os.path.join(target_directory, file_path)
if os.path.exists(full_path):
os.remove(full_path)

# 追加・変更されたファイルの処理
for file_path in changes[‘added’] + changes[‘modified’]:
source_path = os.path.join(self.base_path, ‘new_version’, file_path)
target_path = os.path.join(target_directory, file_path)

# ディレクトリの作成
os.makedirs(os.path.dirname(target_path), exist_ok=True)

# ファイルのコピー
shutil.copy2(source_path, target_path)

return True

except Exception as e:
print(f”パッチ適用エラー: {e}”)
return False

class PatchDistributionManager:
def __init__(self, cdn_config: Dict):
self.cdn_config = cdn_config
self.patch_server = cdn_config[‘server_url’]def upload_patch(self, patch_file: str, version: str) -> bool:
“””パッチファイルのアップロード”””
upload_url = f”{self.patch_server}/patches/{version}”

with open(patch_file, ‘rb’) as f:
files = {‘patch’: f}
response = requests.post(upload_url, files=files)

return response.status_code == 200

def notify_clients(self, patch_info: Dict) -> None:
“””クライアントへの更新通知”””
notification_data = {
‘type’: ‘patch_available’,
‘version’: patch_info[‘version’],
‘size’: patch_info[‘size’],
‘download_url’: patch_info[‘download_url’],
‘checksum’: patch_info[‘checksum’]
}

# WebSocketまたはHTTPポーリングで通知
self.send_notification(notification_data)

import logging
from datetime import datetime# ログ設定
logging.basicConfig(
level=logging.INFO,
format=’%(asctime)s – %(name)s – %(levelname)s – %(message)s’,
handlers=[
logging.FileHandler(‘modpack_sync.log’),
logging.StreamHandler()
]
)

class SyncLogger:
def __init__(self):
self.logger = logging.getLogger(‘ModpackSync’)

def log_sync_start(self, modpack_name: str):
self.logger.info(f”Modpack同期開始: {modpack_name}”)

def log_sync_complete(self, modpack_name: str, duration: float):
self.logger.info(f”Modpack同期完了: {modpack_name} ({duration:.2f}秒)”)

def log_error(self, error_message: str, exception: Exception = None):
if exception:
self.logger.error(f”エラー: {error_message}”, exc_info=exception)
else:
self.logger.error(f”エラー: {error_message}”)

def verify_file_integrity(file_path: str, expected_hash: str) -> bool:
“””ファイル整合性の検証”””
actual_hash = calculate_file_hash(file_path)
return actual_hash == expected_hashdef secure_download(url: str, file_path: str, expected_hash: str) -> bool:
“””セキュアダウンロード”””
temp_path = file_path + “.tmp”

try:
# ファイルのダウンロード
with requests.get(url, stream=True) as response:
response.raise_for_status()

with open(temp_path, ‘wb’) as f:
for chunk in response.iter_content(chunk_size=8192):
f.write(chunk)

# 整合性の検証
if verify_file_integrity(temp_path, expected_hash):
os.rename(temp_path, file_path)
return True
else:
os.remove(temp_path)
return False

except Exception as e:
if os.path.exists(temp_path):
os.remove(temp_path)
raise e