ske087
544 lines
21 KiB
Python
544 lines
21 KiB
Python
"""SSH deployment utilities for player provisioning."""
|
|
import subprocess
|
|
import logging
|
|
import os
|
|
import json
|
|
from typing import Tuple, Dict, Any, Optional
|
|
from datetime import datetime
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Pre-staged player code location in container
|
|
LOCAL_PLAYER_CODE_DIR = '/app/data/player'
|
|
|
|
|
|
def get_local_player_code_status() -> Dict[str, Any]:
|
|
"""
|
|
Check status of pre-staged player code.
|
|
|
|
Returns:
|
|
Dict with availability, version, and path info
|
|
"""
|
|
try:
|
|
if not os.path.isdir(LOCAL_PLAYER_CODE_DIR):
|
|
return {
|
|
'available': False,
|
|
'reason': 'Directory not found',
|
|
'path': LOCAL_PLAYER_CODE_DIR
|
|
}
|
|
|
|
# Check if git repository
|
|
git_dir = os.path.join(LOCAL_PLAYER_CODE_DIR, '.git')
|
|
if not os.path.isdir(git_dir):
|
|
return {
|
|
'available': False,
|
|
'reason': 'Not a git repository',
|
|
'path': LOCAL_PLAYER_CODE_DIR
|
|
}
|
|
|
|
# Get current git version
|
|
try:
|
|
result = subprocess.run(
|
|
['git', '-C', LOCAL_PLAYER_CODE_DIR, 'rev-parse', '--short', 'HEAD'],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=5
|
|
)
|
|
version = result.stdout.strip() if result.returncode == 0 else 'unknown'
|
|
except:
|
|
version = 'unknown'
|
|
|
|
# Get directory size
|
|
try:
|
|
result = subprocess.run(
|
|
['du', '-sh', LOCAL_PLAYER_CODE_DIR],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=5
|
|
)
|
|
size = result.stdout.split()[0] if result.returncode == 0 else 'unknown'
|
|
except:
|
|
size = 'unknown'
|
|
|
|
return {
|
|
'available': True,
|
|
'path': LOCAL_PLAYER_CODE_DIR,
|
|
'version': version,
|
|
'size': size,
|
|
'updated': os.path.getmtime(git_dir),
|
|
'reason': 'Pre-staged code ready for deployment'
|
|
}
|
|
except Exception as e:
|
|
logger.warning(f'Error checking player code status: {str(e)}')
|
|
return {
|
|
'available': False,
|
|
'reason': f'Status check failed: {str(e)}',
|
|
'path': LOCAL_PLAYER_CODE_DIR
|
|
}
|
|
|
|
|
|
def test_ssh_connection(hostname: str, username: str, password: str, port: int = 22) -> Dict[str, Any]:
|
|
"""
|
|
Test SSH connection to a remote host.
|
|
|
|
Args:
|
|
hostname: Target hostname or IP
|
|
username: SSH username
|
|
password: SSH password
|
|
port: SSH port (default 22)
|
|
|
|
Returns:
|
|
Dict with status, message, and timestamp
|
|
"""
|
|
try:
|
|
# Use sshpass to test connection without interactive prompt
|
|
cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-o', 'ConnectTimeout=10',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
'echo "SSH connection successful"'
|
|
]
|
|
|
|
result = subprocess.run(
|
|
cmd,
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=15
|
|
)
|
|
|
|
if result.returncode == 0:
|
|
return {
|
|
'success': True,
|
|
'message': f'SSH connection successful to {hostname}',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'output': result.stdout.strip()
|
|
}
|
|
else:
|
|
error_msg = result.stderr.strip() or result.stdout.strip()
|
|
return {
|
|
'success': False,
|
|
'message': f'SSH connection failed: {error_msg}',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': error_msg
|
|
}
|
|
|
|
except subprocess.TimeoutExpired:
|
|
return {
|
|
'success': False,
|
|
'message': f'SSH connection timeout to {hostname}',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': 'Connection timeout (10s)'
|
|
}
|
|
except Exception as e:
|
|
logger.error(f'SSH test error: {str(e)}')
|
|
return {
|
|
'success': False,
|
|
'message': f'SSH connection error: {str(e)}',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': str(e)
|
|
}
|
|
|
|
|
|
def generate_player_config(
|
|
player_name: str,
|
|
server_url: str,
|
|
api_key: str,
|
|
player_id: str = None,
|
|
location: str = None
|
|
) -> str:
|
|
"""
|
|
Generate player configuration JSON for connecting to DigiServer.
|
|
|
|
Args:
|
|
player_name: Name of the player
|
|
server_url: DigiServer base URL (e.g., http://localhost/digiserver)
|
|
api_key: API authentication key
|
|
player_id: Optional player ID (defaults to player_name)
|
|
location: Optional player location/description
|
|
|
|
Returns:
|
|
JSON configuration string
|
|
"""
|
|
config = {
|
|
"player": {
|
|
"name": player_name,
|
|
"id": player_id or player_name,
|
|
"location": location or "",
|
|
"version": "2.0"
|
|
},
|
|
"server": {
|
|
"url": server_url,
|
|
"api_endpoint": f"{server_url}/api",
|
|
"authentication": {
|
|
"type": "api_key",
|
|
"key": api_key
|
|
},
|
|
"endpoints": {
|
|
"playlists": f"{server_url}/api/playlists",
|
|
"content": f"{server_url}/api/content",
|
|
"schedule": f"{server_url}/api/schedule",
|
|
"heartbeat": f"{server_url}/api/player/heartbeat",
|
|
"logs": f"{server_url}/api/player/logs"
|
|
}
|
|
},
|
|
"playback": {
|
|
"audio_enabled": True,
|
|
"video_enabled": True,
|
|
"max_resolution": "4K",
|
|
"refresh_interval": 60,
|
|
"rotation": "0"
|
|
},
|
|
"networking": {
|
|
"timeout": 30,
|
|
"retry_count": 3,
|
|
"retry_delay": 5
|
|
}
|
|
}
|
|
|
|
return json.dumps(config, indent=2)
|
|
|
|
|
|
def deploy_player_to_host(
|
|
hostname: str,
|
|
username: str,
|
|
password: str,
|
|
player_name: str,
|
|
repo_url: str = 'https://gitea.moto-adv.com/ske087/Kiwy-Signage.git',
|
|
deploy_path: str = None, # Default: /home/[user]/kiwy-signage
|
|
port: int = 22,
|
|
server_url: str = None, # DigiServer URL for player to connect to
|
|
server_api_key: str = None # API key for player authentication
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Deploy player code to remote host.
|
|
|
|
Args:
|
|
hostname: Target hostname or IP
|
|
username: SSH username
|
|
password: SSH password
|
|
player_name: Name for the player instance
|
|
repo_url: Git repository URL
|
|
deploy_path: Path where to deploy on remote host (default: /home/[user]/kiwy-signage)
|
|
port: SSH port (default 22)
|
|
server_url: DigiServer URL for player connection
|
|
server_api_key: API key for player authentication
|
|
|
|
Returns:
|
|
Dict with deployment status and output
|
|
"""
|
|
# Set default deployment path to user's home directory
|
|
if deploy_path is None:
|
|
deploy_path = f'/home/{username}/kiwy-signage'
|
|
try:
|
|
# Step 1: Verify host accessibility
|
|
test_result = test_ssh_connection(hostname, username, password, port)
|
|
if not test_result['success']:
|
|
return {
|
|
'success': False,
|
|
'message': 'Cannot deploy: SSH connection failed',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': test_result['message'],
|
|
'steps': []
|
|
}
|
|
|
|
steps = [
|
|
{
|
|
'step': 'SSH Connection Test',
|
|
'status': 'completed',
|
|
'message': 'SSH connection successful',
|
|
'timestamp': datetime.now().isoformat()
|
|
}
|
|
]
|
|
|
|
# Step 2: Create deployment directory
|
|
try:
|
|
mkdir_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'mkdir -p {deploy_path}'
|
|
]
|
|
result = subprocess.run(mkdir_cmd, capture_output=True, text=True, timeout=30)
|
|
steps.append({
|
|
'step': 'Create Deploy Directory',
|
|
'status': 'completed' if result.returncode == 0 else 'failed',
|
|
'message': f'Directory {deploy_path} created',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
except Exception as e:
|
|
steps.append({
|
|
'step': 'Create Deploy Directory',
|
|
'status': 'failed',
|
|
'message': f'Failed: {str(e)}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
return {
|
|
'success': False,
|
|
'message': f'Deployment failed at step: Create Deploy Directory',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': str(e),
|
|
'steps': steps
|
|
}
|
|
|
|
# Step 3: Deploy code (use local if available, otherwise clone from git)
|
|
try:
|
|
code_status = get_local_player_code_status()
|
|
|
|
if code_status['available']:
|
|
# Use pre-staged player code via rsync
|
|
logger.info(f'Using pre-staged player code (version: {code_status.get("version", "unknown")})')
|
|
|
|
rsync_cmd = [
|
|
'sshpass', '-p', password,
|
|
'rsync', '-avz',
|
|
'--delete',
|
|
'-e', f'ssh -o StrictHostKeyChecking=no -p {port}',
|
|
f'{LOCAL_PLAYER_CODE_DIR}/',
|
|
f'{username}@{hostname}:{deploy_path}/'
|
|
]
|
|
result = subprocess.run(rsync_cmd, capture_output=True, text=True, timeout=300)
|
|
|
|
steps.append({
|
|
'step': 'Deploy Code',
|
|
'status': 'completed' if result.returncode == 0 else 'failed',
|
|
'message': f'Code deployed via rsync (version: {code_status.get("version", "local")})',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
|
|
if result.returncode != 0:
|
|
logger.warning(f'Rsync failed, falling back to git clone: {result.stderr}')
|
|
# Fall back to git clone
|
|
raise Exception('Rsync failed, retrying with git')
|
|
else:
|
|
# No local code, clone from repository
|
|
logger.info(f'No pre-staged code available ({code_status.get("reason", "unknown")}), cloning from repository')
|
|
raise Exception('Local code not available')
|
|
|
|
except Exception as rsync_error:
|
|
# Fallback: Clone or pull repository
|
|
try:
|
|
logger.info(f'Deploying via git: {rsync_error}')
|
|
|
|
# Check if repo already exists
|
|
check_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'[ -d {deploy_path}/.git ]'
|
|
]
|
|
result = subprocess.run(check_cmd, capture_output=True, text=True, timeout=10)
|
|
|
|
if result.returncode == 0:
|
|
# Repo exists, pull latest
|
|
git_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'cd {deploy_path} && git pull origin main 2>&1'
|
|
]
|
|
git_msg = 'Pull latest code'
|
|
else:
|
|
# Clone repository
|
|
git_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'git clone {repo_url} {deploy_path} 2>&1'
|
|
]
|
|
git_msg = 'Clone repository'
|
|
|
|
result = subprocess.run(git_cmd, capture_output=True, text=True, timeout=120)
|
|
steps.append({
|
|
'step': 'Deploy Code',
|
|
'status': 'completed' if result.returncode == 0 else 'failed',
|
|
'message': f'{git_msg}: {result.stdout.split(chr(10))[0][:100]}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
'success': False,
|
|
'message': f'Deployment failed at step: Deploy Code',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': result.stderr or result.stdout,
|
|
'steps': steps
|
|
}
|
|
except Exception as e:
|
|
steps.append({
|
|
'step': 'Deploy Code',
|
|
'status': 'failed',
|
|
'message': f'Failed: {str(e)}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
return {
|
|
'success': False,
|
|
'message': f'Deployment failed at step: Deploy Code',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': str(e),
|
|
'steps': steps
|
|
}
|
|
|
|
# Step 3.5: Generate player configuration
|
|
try:
|
|
if server_url and server_api_key:
|
|
config_content = generate_player_config(
|
|
player_name=player_name,
|
|
server_url=server_url,
|
|
api_key=server_api_key
|
|
)
|
|
|
|
# Write config file to remote host
|
|
write_config_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'cat > {deploy_path}/config.json << \'EOF\'\n{config_content}\nEOF'
|
|
]
|
|
result = subprocess.run(write_config_cmd, capture_output=True, text=True, timeout=30)
|
|
steps.append({
|
|
'step': 'Configure Player',
|
|
'status': 'completed' if result.returncode == 0 else 'warning',
|
|
'message': f'Player configuration created',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
except Exception as e:
|
|
logger.warning(f'Failed to create player config: {str(e)}')
|
|
|
|
# Step 4: Run installation script
|
|
try:
|
|
# First check if install script exists
|
|
check_script = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'[ -f {deploy_path}/install.sh ] || [ -f {deploy_path}/setup.sh ] || [ -f {deploy_path}/install_player.sh ]'
|
|
]
|
|
script_check = subprocess.run(check_script, capture_output=True, text=True, timeout=10)
|
|
|
|
if script_check.returncode == 0:
|
|
# Find the install script
|
|
find_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'ls {deploy_path}/install*.sh {deploy_path}/setup.sh {deploy_path}/*.sh 2>/dev/null | head -1'
|
|
]
|
|
find_result = subprocess.run(find_cmd, capture_output=True, text=True, timeout=10)
|
|
install_script = find_result.stdout.strip().split('\n')[0]
|
|
|
|
if install_script:
|
|
# Run the install script
|
|
install_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'cd {deploy_path} && bash {install_script} 2>&1'
|
|
]
|
|
result = subprocess.run(install_cmd, capture_output=True, text=True, timeout=300)
|
|
steps.append({
|
|
'step': 'Run Installation Script',
|
|
'status': 'completed' if result.returncode == 0 else 'completed_with_warnings',
|
|
'message': f'Installation script executed: {install_script}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
else:
|
|
steps.append({
|
|
'step': 'Run Installation Script',
|
|
'status': 'skipped',
|
|
'message': 'No installation script found (manual setup may be required)',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
else:
|
|
steps.append({
|
|
'step': 'Run Installation Script',
|
|
'status': 'skipped',
|
|
'message': 'No installation script found',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
except Exception as e:
|
|
steps.append({
|
|
'step': 'Run Installation Script',
|
|
'status': 'error',
|
|
'message': f'Error running installation: {str(e)}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
logger.error(f'Installation script error: {str(e)}')
|
|
|
|
# Step 5: Start player service (execute start.sh)
|
|
try:
|
|
# Check if start.sh exists
|
|
check_start = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'[ -f {deploy_path}/start.sh ]'
|
|
]
|
|
start_check = subprocess.run(check_start, capture_output=True, text=True, timeout=10)
|
|
|
|
if start_check.returncode == 0:
|
|
# Make sure start.sh is executable and run it
|
|
start_cmd = [
|
|
'sshpass', '-p', password,
|
|
'ssh', '-o', 'StrictHostKeyChecking=no',
|
|
'-p', str(port),
|
|
f'{username}@{hostname}',
|
|
f'cd {deploy_path} && chmod +x start.sh && bash start.sh 2>&1'
|
|
]
|
|
result = subprocess.run(start_cmd, capture_output=True, text=True, timeout=300)
|
|
|
|
# Capture first line of output for feedback
|
|
output_msg = result.stdout.split('\n')[0][:100] if result.stdout else 'Started'
|
|
|
|
steps.append({
|
|
'step': 'Start Player Service',
|
|
'status': 'completed' if result.returncode == 0 else 'completed_with_warnings',
|
|
'message': f'Player service started: {output_msg}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
logger.info(f'Player service started on {hostname} at {deploy_path}')
|
|
else:
|
|
steps.append({
|
|
'step': 'Start Player Service',
|
|
'status': 'warning',
|
|
'message': 'start.sh not found - player may require manual startup',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
logger.warning(f'start.sh not found at {deploy_path}/start.sh on {hostname}')
|
|
except Exception as e:
|
|
steps.append({
|
|
'step': 'Start Player Service',
|
|
'status': 'error',
|
|
'message': f'Error starting player service: {str(e)}',
|
|
'timestamp': datetime.now().isoformat()
|
|
})
|
|
logger.error(f'Failed to start player service: {str(e)}')
|
|
|
|
return {
|
|
'success': True,
|
|
'message': f'Player "{player_name}" deployed successfully to {hostname}',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'deploy_path': deploy_path,
|
|
'steps': steps
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f'Deployment error: {str(e)}')
|
|
return {
|
|
'success': False,
|
|
'message': f'Unexpected deployment error: {str(e)}',
|
|
'timestamp': datetime.now().isoformat(),
|
|
'error': str(e),
|
|
'steps': []
|
|
}
|