670 lines
22 KiB
Python
670 lines
22 KiB
Python
"""
|
|
Dell iDRAC 멀티 서버 펌웨어 관리 라우트
|
|
backend/routes/idrac_routes.py
|
|
- CSRF 보호 제외 추가
|
|
"""
|
|
|
|
from flask import Blueprint, render_template, request, jsonify, current_app
|
|
from werkzeug.utils import secure_filename
|
|
import os
|
|
from datetime import datetime
|
|
from backend.services.idrac_redfish_client import DellRedfishClient
|
|
from backend.models.idrac_server import IdracServer, db
|
|
from flask_socketio import emit
|
|
import threading
|
|
|
|
# Blueprint 생성
|
|
idrac_bp = Blueprint('idrac', __name__, url_prefix='/idrac')
|
|
|
|
# 설정
|
|
UPLOAD_FOLDER = 'uploads/firmware'
|
|
ALLOWED_EXTENSIONS = {'exe', 'bin'}
|
|
MAX_FILE_SIZE = 500 * 1024 * 1024 # 500MB
|
|
|
|
def allowed_file(filename):
|
|
"""허용된 파일 형식 확인"""
|
|
return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
|
|
|
|
# ========================================
|
|
# 메인 페이지
|
|
# ========================================
|
|
|
|
@idrac_bp.route('/')
|
|
def index():
|
|
"""iDRAC 멀티 서버 관리 메인 페이지"""
|
|
return render_template('idrac_firmware.html')
|
|
|
|
# ========================================
|
|
# 서버 관리 API
|
|
# ========================================
|
|
|
|
@idrac_bp.route('/api/servers', methods=['GET'])
|
|
def get_servers():
|
|
"""등록된 서버 목록 조회"""
|
|
try:
|
|
group = request.args.get('group') # 그룹 필터
|
|
|
|
query = IdracServer.query.filter_by(is_active=True)
|
|
if group and group != 'all':
|
|
query = query.filter_by(group_name=group)
|
|
|
|
servers = query.order_by(IdracServer.name).all()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'servers': [s.to_dict() for s in servers]
|
|
})
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/servers', methods=['POST'])
|
|
def add_server():
|
|
"""서버 추가"""
|
|
try:
|
|
data = request.json
|
|
|
|
# 필수 필드 확인
|
|
if not all([data.get('name'), data.get('ip_address'), data.get('password')]):
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '필수 필드를 모두 입력하세요 (서버명, IP, 비밀번호)'
|
|
})
|
|
|
|
# 중복 IP 확인
|
|
existing = IdracServer.query.filter_by(ip_address=data['ip_address']).first()
|
|
if existing:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'이미 등록된 IP입니다: {data["ip_address"]}'
|
|
})
|
|
|
|
# 서버 생성
|
|
server = IdracServer(
|
|
name=data['name'],
|
|
ip_address=data['ip_address'],
|
|
username=data.get('username', 'root'),
|
|
password=data['password'],
|
|
group_name=data.get('group_name'),
|
|
location=data.get('location'),
|
|
model=data.get('model'),
|
|
notes=data.get('notes')
|
|
)
|
|
|
|
db.session.add(server)
|
|
db.session.commit()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'message': f'서버 {server.name} 추가 완료',
|
|
'server': server.to_dict()
|
|
})
|
|
|
|
except Exception as e:
|
|
db.session.rollback()
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/servers/<int:server_id>', methods=['PUT'])
|
|
def update_server(server_id):
|
|
"""서버 정보 수정"""
|
|
try:
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 찾을 수 없습니다'
|
|
})
|
|
|
|
data = request.json
|
|
|
|
# 업데이트
|
|
if 'name' in data:
|
|
server.name = data['name']
|
|
if 'ip_address' in data:
|
|
server.ip_address = data['ip_address']
|
|
if 'username' in data:
|
|
server.username = data['username']
|
|
if 'password' in data:
|
|
server.password = data['password']
|
|
if 'group_name' in data:
|
|
server.group_name = data['group_name']
|
|
if 'location' in data:
|
|
server.location = data['location']
|
|
if 'model' in data:
|
|
server.model = data['model']
|
|
if 'notes' in data:
|
|
server.notes = data['notes']
|
|
|
|
db.session.commit()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'message': '서버 정보 수정 완료',
|
|
'server': server.to_dict()
|
|
})
|
|
|
|
except Exception as e:
|
|
db.session.rollback()
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/servers/<int:server_id>', methods=['DELETE'])
|
|
def delete_server(server_id):
|
|
"""서버 삭제 (소프트 삭제)"""
|
|
try:
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 찾을 수 없습니다'
|
|
})
|
|
|
|
server.is_active = False
|
|
db.session.commit()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'message': f'서버 {server.name} 삭제 완료'
|
|
})
|
|
|
|
except Exception as e:
|
|
db.session.rollback()
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/groups', methods=['GET'])
|
|
def get_groups():
|
|
"""등록된 그룹 목록"""
|
|
try:
|
|
groups = db.session.query(IdracServer.group_name)\
|
|
.filter(IdracServer.is_active == True)\
|
|
.filter(IdracServer.group_name.isnot(None))\
|
|
.distinct()\
|
|
.all()
|
|
|
|
group_list = [g[0] for g in groups if g[0]]
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'groups': group_list
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
# ========================================
|
|
# 연결 및 상태 확인 API
|
|
# ========================================
|
|
|
|
@idrac_bp.route('/api/servers/<int:server_id>/test', methods=['POST'])
|
|
def test_connection(server_id):
|
|
"""단일 서버 연결 테스트"""
|
|
try:
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 찾을 수 없습니다'
|
|
})
|
|
|
|
client = DellRedfishClient(server.ip_address, server.username, server.password)
|
|
|
|
if client.check_connection():
|
|
server.status = 'online'
|
|
server.last_connected = datetime.utcnow()
|
|
db.session.commit()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'message': f'{server.name} 연결 성공'
|
|
})
|
|
else:
|
|
server.status = 'offline'
|
|
db.session.commit()
|
|
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'{server.name} 연결 실패'
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/servers/test-multi', methods=['POST'])
|
|
def test_connections_multi():
|
|
"""다중 서버 일괄 연결 테스트"""
|
|
try:
|
|
data = request.json
|
|
server_ids = data.get('server_ids', [])
|
|
|
|
if not server_ids:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 선택하세요'
|
|
})
|
|
|
|
results = []
|
|
|
|
for server_id in server_ids:
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
continue
|
|
|
|
try:
|
|
client = DellRedfishClient(server.ip_address, server.username, server.password)
|
|
|
|
if client.check_connection():
|
|
server.status = 'online'
|
|
server.last_connected = datetime.utcnow()
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': True,
|
|
'message': '연결 성공'
|
|
})
|
|
else:
|
|
server.status = 'offline'
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': False,
|
|
'message': '연결 실패'
|
|
})
|
|
|
|
except Exception as e:
|
|
server.status = 'offline'
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': False,
|
|
'message': str(e)
|
|
})
|
|
|
|
db.session.commit()
|
|
|
|
success_count = sum(1 for r in results if r['success'])
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'results': results,
|
|
'summary': {
|
|
'total': len(results),
|
|
'success': success_count,
|
|
'failed': len(results) - success_count
|
|
}
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/servers/<int:server_id>/firmware', methods=['GET'])
|
|
def get_server_firmware(server_id):
|
|
"""단일 서버 펌웨어 버전 조회"""
|
|
try:
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 찾을 수 없습니다'
|
|
})
|
|
|
|
client = DellRedfishClient(server.ip_address, server.username, server.password)
|
|
inventory = client.get_firmware_inventory()
|
|
|
|
# BIOS 버전 업데이트
|
|
for item in inventory:
|
|
if 'BIOS' in item.get('Name', ''):
|
|
server.current_bios = item.get('Version')
|
|
break
|
|
|
|
db.session.commit()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'data': inventory
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
# ========================================
|
|
# 멀티 서버 펌웨어 업로드 API
|
|
# ========================================
|
|
|
|
@idrac_bp.route('/api/upload-multi', methods=['POST'])
|
|
def upload_multi():
|
|
"""다중 서버에 펌웨어 일괄 업로드"""
|
|
try:
|
|
if 'file' not in request.files:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '파일이 없습니다'
|
|
})
|
|
|
|
file = request.files['file']
|
|
server_ids_str = request.form.get('server_ids')
|
|
|
|
if not server_ids_str:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 선택하세요'
|
|
})
|
|
|
|
server_ids = [int(x) for x in server_ids_str.split(',')]
|
|
|
|
if file.filename == '':
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '파일이 선택되지 않았습니다'
|
|
})
|
|
|
|
if not allowed_file(file.filename):
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '허용되지 않은 파일 형식입니다 (.exe, .bin만 가능)'
|
|
})
|
|
|
|
# 로컬에 임시 저장
|
|
filename = secure_filename(file.filename)
|
|
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
|
|
local_path = os.path.join(UPLOAD_FOLDER, filename)
|
|
file.save(local_path)
|
|
|
|
# 백그라운드 스레드로 업로드 시작
|
|
from backend.services import watchdog_handler
|
|
socketio = watchdog_handler.socketio
|
|
|
|
def upload_to_servers():
|
|
results = []
|
|
|
|
for idx, server_id in enumerate(server_ids):
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
continue
|
|
|
|
try:
|
|
# 진행 상황 전송
|
|
if socketio:
|
|
socketio.emit('upload_progress', {
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'status': 'uploading',
|
|
'progress': 0,
|
|
'message': '업로드 시작...'
|
|
})
|
|
|
|
server.status = 'updating'
|
|
db.session.commit()
|
|
|
|
client = DellRedfishClient(server.ip_address, server.username, server.password)
|
|
result = client.upload_firmware_staged(local_path)
|
|
|
|
if result['success']:
|
|
server.status = 'online'
|
|
server.last_updated = datetime.utcnow()
|
|
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': True,
|
|
'job_id': result['job_id'],
|
|
'message': '업로드 완료'
|
|
})
|
|
|
|
if socketio:
|
|
socketio.emit('upload_progress', {
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'status': 'completed',
|
|
'progress': 100,
|
|
'message': '업로드 완료',
|
|
'job_id': result['job_id']
|
|
})
|
|
else:
|
|
server.status = 'online'
|
|
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': False,
|
|
'message': result.get('message', '업로드 실패')
|
|
})
|
|
|
|
if socketio:
|
|
socketio.emit('upload_progress', {
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'status': 'failed',
|
|
'progress': 0,
|
|
'message': result.get('message', '업로드 실패')
|
|
})
|
|
|
|
db.session.commit()
|
|
|
|
except Exception as e:
|
|
server.status = 'online'
|
|
db.session.commit()
|
|
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': False,
|
|
'message': str(e)
|
|
})
|
|
|
|
if socketio:
|
|
socketio.emit('upload_progress', {
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'status': 'failed',
|
|
'progress': 0,
|
|
'message': str(e)
|
|
})
|
|
|
|
# 최종 결과 전송
|
|
if socketio:
|
|
success_count = sum(1 for r in results if r['success'])
|
|
socketio.emit('upload_complete', {
|
|
'results': results,
|
|
'summary': {
|
|
'total': len(results),
|
|
'success': success_count,
|
|
'failed': len(results) - success_count
|
|
}
|
|
})
|
|
|
|
# 스레드 시작
|
|
thread = threading.Thread(target=upload_to_servers)
|
|
thread.daemon = True
|
|
thread.start()
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'message': f'{len(server_ids)}대 서버에 업로드 시작',
|
|
'filename': filename
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'업로드 오류: {str(e)}'
|
|
})
|
|
|
|
# ========================================
|
|
# 기존 단일 서버 API (호환성 유지)
|
|
# ========================================
|
|
|
|
@idrac_bp.route('/api/files/local', methods=['GET'])
|
|
def list_local_files():
|
|
"""로컬에 저장된 DUP 파일 목록"""
|
|
try:
|
|
files = []
|
|
|
|
if os.path.exists(UPLOAD_FOLDER):
|
|
for filename in os.listdir(UPLOAD_FOLDER):
|
|
filepath = os.path.join(UPLOAD_FOLDER, filename)
|
|
if os.path.isfile(filepath):
|
|
file_size = os.path.getsize(filepath)
|
|
files.append({
|
|
'name': filename,
|
|
'size': file_size,
|
|
'size_mb': round(file_size / (1024 * 1024), 2),
|
|
'uploaded_at': datetime.fromtimestamp(
|
|
os.path.getmtime(filepath)
|
|
).strftime('%Y-%m-%d %H:%M:%S')
|
|
})
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'files': files
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
@idrac_bp.route('/api/files/local/<filename>', methods=['DELETE'])
|
|
def delete_local_file(filename):
|
|
"""로컬 DUP 파일 삭제"""
|
|
try:
|
|
filepath = os.path.join(UPLOAD_FOLDER, secure_filename(filename))
|
|
|
|
if os.path.exists(filepath):
|
|
os.remove(filepath)
|
|
return jsonify({
|
|
'success': True,
|
|
'message': f'{filename} 삭제 완료'
|
|
})
|
|
else:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '파일을 찾을 수 없습니다'
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'삭제 오류: {str(e)}'
|
|
})
|
|
|
|
# ========================================
|
|
# 서버 재부팅 API (멀티)
|
|
# ========================================
|
|
|
|
@idrac_bp.route('/api/servers/reboot-multi', methods=['POST'])
|
|
def reboot_servers_multi():
|
|
"""선택한 서버들 일괄 재부팅"""
|
|
try:
|
|
data = request.json
|
|
server_ids = data.get('server_ids', [])
|
|
reboot_type = data.get('type', 'GracefulRestart')
|
|
|
|
if not server_ids:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': '서버를 선택하세요'
|
|
})
|
|
|
|
results = []
|
|
|
|
for server_id in server_ids:
|
|
server = IdracServer.query.get(server_id)
|
|
if not server:
|
|
continue
|
|
|
|
try:
|
|
client = DellRedfishClient(server.ip_address, server.username, server.password)
|
|
result = client.reboot_server(reboot_type)
|
|
|
|
if result:
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': True,
|
|
'message': '재부팅 시작'
|
|
})
|
|
else:
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': False,
|
|
'message': '재부팅 실패'
|
|
})
|
|
|
|
except Exception as e:
|
|
results.append({
|
|
'server_id': server.id,
|
|
'server_name': server.name,
|
|
'success': False,
|
|
'message': str(e)
|
|
})
|
|
|
|
success_count = sum(1 for r in results if r['success'])
|
|
|
|
return jsonify({
|
|
'success': True,
|
|
'results': results,
|
|
'summary': {
|
|
'total': len(results),
|
|
'success': success_count,
|
|
'failed': len(results) - success_count
|
|
}
|
|
})
|
|
|
|
except Exception as e:
|
|
return jsonify({
|
|
'success': False,
|
|
'message': f'오류: {str(e)}'
|
|
})
|
|
|
|
|
|
# Blueprint 등록 함수
|
|
def register_idrac_routes(app):
|
|
"""
|
|
iDRAC 멀티 서버 관리 Blueprint 등록
|
|
|
|
Args:
|
|
app: Flask 애플리케이션 인스턴스
|
|
"""
|
|
# uploads 디렉토리 생성
|
|
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
|
|
|
|
# Blueprint 등록
|
|
app.register_blueprint(idrac_bp)
|
|
|
|
# CSRF 보호 제외 - iDRAC API 엔드포인트
|
|
try:
|
|
from flask_wtf.csrf import CSRFProtect
|
|
csrf = CSRFProtect()
|
|
# API 엔드포인트는 CSRF 검증 제외
|
|
csrf.exempt(idrac_bp)
|
|
except:
|
|
pass # CSRF 설정 실패해도 계속 진행
|
|
|
|
# DB 테이블 생성
|
|
with app.app_context():
|
|
db.create_all()
|