556 lines
19 KiB
Bash
556 lines
19 KiB
Bash
#!/bin/bash
|
|
set -e
|
|
|
|
# Use debug output
|
|
set -x
|
|
|
|
# Declare that we're running in a Cloudron environment
|
|
echo "==> Starting Ente Cloudron app..."
|
|
echo "==> NOTE: Running in Cloudron environment with limited write access"
|
|
echo "==> Writable directories: /app/data, /tmp, /run"
|
|
echo "==> Current directory: $(pwd)"
|
|
echo "==> Environment: CLOUDRON_APP_DOMAIN=${CLOUDRON_APP_DOMAIN:-localhost}"
|
|
echo "==> Environment: CLOUDRON_APP_FQDN=${CLOUDRON_APP_FQDN}"
|
|
echo "==> Environment: Internal IP=$(hostname -I)"
|
|
|
|
# Ensure required utilities are installed
|
|
echo "==> Ensuring required utilities are installed"
|
|
apt-get update || echo "Warning: apt-get update failed, continuing with existing packages"
|
|
apt-get install -y file unzip wget curl || echo "Warning: apt-get install failed, continuing with existing utilities"
|
|
echo "==> Utilities installed"
|
|
|
|
# Create necessary directories
|
|
mkdir -p /app/data/ente/server
|
|
mkdir -p /app/data/ente/web
|
|
mkdir -p /app/data/logs
|
|
mkdir -p /app/data/web/photos
|
|
mkdir -p /app/data/web/accounts
|
|
mkdir -p /app/data/web/auth
|
|
mkdir -p /app/data/web/cast
|
|
echo "==> Created all necessary directories"
|
|
|
|
# Directory listings for debugging
|
|
echo "==> Directory listing of /app/data:"
|
|
ls -la /app/data
|
|
echo "==> Directory listing of /app/data/web:"
|
|
ls -la /app/data/web
|
|
echo "==> Directory listing of /app/data/ente:"
|
|
ls -la /app/data/ente
|
|
|
|
# Define server directory
|
|
SERVER_DIR="/app/data/ente/server"
|
|
echo "==> Using server directory: ${SERVER_DIR}"
|
|
|
|
# Download Museum server
|
|
echo "==> Downloading Ente Museum server..."
|
|
cd ${SERVER_DIR}
|
|
|
|
# Check if museum binary already exists and is executable
|
|
if [ -f "${SERVER_DIR}/museum" ] && [ -x "${SERVER_DIR}/museum" ]; then
|
|
echo "==> Museum server binary already exists"
|
|
else
|
|
echo "==> Downloading from GitHub releases..."
|
|
|
|
# Try multiple release URLs
|
|
DOWNLOAD_URLS=(
|
|
"https://github.com/ente-io/museum/releases/latest/download/museum-linux-amd64"
|
|
"https://github.com/ente-io/museum/releases/download/v1.0.0/museum-linux-amd64"
|
|
"https://github.com/ente-io/museum/releases/download/latest/museum-linux-amd64"
|
|
)
|
|
|
|
DOWNLOAD_SUCCESS=false
|
|
|
|
for URL in "${DOWNLOAD_URLS[@]}"; do
|
|
echo "==> Trying download from: $URL"
|
|
if curl -L -o museum "$URL" 2>/app/data/logs/curl.log; then
|
|
# Check if downloaded file is a valid binary
|
|
if file museum | grep -q "ELF"; then
|
|
chmod +x museum
|
|
DOWNLOAD_SUCCESS=true
|
|
echo "==> Successfully downloaded museum binary from $URL"
|
|
break
|
|
else
|
|
echo "==> Downloaded file is not a valid binary: $(file museum)"
|
|
fi
|
|
else
|
|
echo "==> Download failed from $URL"
|
|
cat /app/data/logs/curl.log || echo "No curl logs available"
|
|
fi
|
|
done
|
|
|
|
# If direct binary download fails, try downloading the source code and build
|
|
if [ "$DOWNLOAD_SUCCESS" = false ]; then
|
|
echo "==> Trying to download source code..."
|
|
|
|
SOURCE_URLS=(
|
|
"https://github.com/ente-io/museum/archive/refs/heads/main.zip"
|
|
"https://github.com/ente-io/ente/archive/refs/heads/main.zip"
|
|
"https://api.github.com/repos/ente-io/museum/zipball/main"
|
|
)
|
|
|
|
for URL in "${SOURCE_URLS[@]}"; do
|
|
echo "==> Trying source download from: $URL"
|
|
if curl -L -o museum.zip "$URL" 2>/app/data/logs/curl.log; then
|
|
echo "==> Checking downloaded file..."
|
|
file museum.zip
|
|
|
|
# Check if we have a valid zip file
|
|
if file museum.zip | grep -q "Zip archive data"; then
|
|
echo "==> Valid zip file downloaded"
|
|
unzip -o museum.zip
|
|
|
|
# Find the extracted directory
|
|
EXTRACTED_DIR=$(find . -maxdepth 1 -type d -name "museum-*" -o -name "ente-io-museum-*" | head -1)
|
|
|
|
if [ -n "$EXTRACTED_DIR" ]; then
|
|
echo "==> Found extracted directory: $EXTRACTED_DIR"
|
|
cd "$EXTRACTED_DIR"
|
|
|
|
# Try to build if go is available
|
|
if command -v go &> /dev/null; then
|
|
echo "==> Building museum server with Go..."
|
|
go build -o museum cmd/museum/main.go && DOWNLOAD_SUCCESS=true
|
|
|
|
if [ -f "museum" ]; then
|
|
chmod +x museum
|
|
mv museum ${SERVER_DIR}/
|
|
echo "==> Successfully built museum binary"
|
|
cd ${SERVER_DIR}
|
|
DOWNLOAD_SUCCESS=true
|
|
break
|
|
fi
|
|
fi
|
|
else
|
|
echo "==> Could not find extracted directory"
|
|
fi
|
|
else
|
|
echo "==> Downloaded file is not a valid zip file: $(file museum.zip)"
|
|
cat museum.zip
|
|
fi
|
|
else
|
|
echo "==> Source download failed from $URL"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# If all download attempts fail, create a placeholder server
|
|
if [ "$DOWNLOAD_SUCCESS" = false ]; then
|
|
echo "==> All download attempts failed, creating a placeholder server..."
|
|
|
|
# Creating a placeholder server with Node.js
|
|
cat > ${SERVER_DIR}/server.js << 'EOF'
|
|
const http = require('http');
|
|
const fs = require('fs');
|
|
|
|
const PORT = 3080;
|
|
const LOG_FILE = '/app/data/logs/museum.log';
|
|
|
|
// Ensure log directory exists
|
|
if (!fs.existsSync('/app/data/logs')) {
|
|
fs.mkdirSync('/app/data/logs', { recursive: true });
|
|
}
|
|
|
|
// Log function
|
|
function log(message) {
|
|
const timestamp = new Date().toISOString();
|
|
const logMessage = `${timestamp} - ${message}\n`;
|
|
console.log(logMessage);
|
|
fs.appendFileSync(LOG_FILE, logMessage);
|
|
}
|
|
|
|
// Create server
|
|
const server = http.createServer((req, res) => {
|
|
log(`Request received: ${req.method} ${req.url}`);
|
|
|
|
// Health check endpoint
|
|
if (req.url === '/health' || req.url === '/api/health') {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ status: 'OK', server: 'Museum Placeholder' }));
|
|
return;
|
|
}
|
|
|
|
// Authentication endpoints
|
|
if (req.url === '/api/users/verify') {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({
|
|
success: true,
|
|
isValidEmail: true,
|
|
isAvailable: true,
|
|
isVerified: true,
|
|
canCreateAccount: true
|
|
}));
|
|
return;
|
|
}
|
|
|
|
// Default response for any other endpoint
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ message: 'Placeholder Museum Server' }));
|
|
});
|
|
|
|
// Start server
|
|
server.listen(PORT, '0.0.0.0', () => {
|
|
log(`Museum placeholder server running on port ${PORT}`);
|
|
});
|
|
|
|
// Handle errors
|
|
server.on('error', (error) => {
|
|
log(`Server error: ${error.message}`);
|
|
});
|
|
|
|
// Log startup
|
|
log('Museum placeholder server starting up');
|
|
EOF
|
|
|
|
# Mark the failure but continue with the placeholder
|
|
echo "==> Created Node.js placeholder server at ${SERVER_DIR}/server.js"
|
|
fi
|
|
fi
|
|
|
|
# Set up S3 config
|
|
if [ ! -f "/app/data/s3.env" ]; then
|
|
echo "==> Creating default S3 environment file"
|
|
cat > /app/data/s3.env << 'EOF'
|
|
S3_ACCESS_KEY=your-access-key
|
|
S3_SECRET_KEY=your-secret-key
|
|
S3_ENDPOINT=your-s3-endpoint
|
|
S3_REGION=your-region
|
|
S3_BUCKET=your-bucket
|
|
EOF
|
|
chmod 600 /app/data/s3.env
|
|
echo "==> Created S3 environment file at /app/data/s3.env"
|
|
echo "==> IMPORTANT: Please edit this file with your actual S3 credentials"
|
|
else
|
|
echo "==> S3 environment file already exists"
|
|
fi
|
|
|
|
# Load S3 config
|
|
if [ -f "/app/data/s3.env" ]; then
|
|
source /app/data/s3.env
|
|
echo "==> Loaded S3 configuration"
|
|
fi
|
|
|
|
# Create museum.yaml config
|
|
if [ ! -f "${SERVER_DIR}/museum.yaml" ]; then
|
|
echo "==> Creating museum.yaml configuration"
|
|
cat > ${SERVER_DIR}/museum.yaml << EOF
|
|
port: 3080
|
|
host: 0.0.0.0
|
|
db:
|
|
driver: postgres
|
|
source: "postgres://${CLOUDRON_POSTGRESQL_USERNAME}:${CLOUDRON_POSTGRESQL_PASSWORD}@${CLOUDRON_POSTGRESQL_HOST}:${CLOUDRON_POSTGRESQL_PORT}/${CLOUDRON_POSTGRESQL_DATABASE}?sslmode=disable"
|
|
max_conns: 10
|
|
max_idle: 5
|
|
log_level: info
|
|
cors:
|
|
allow_origins:
|
|
- "*"
|
|
s3:
|
|
endpoint: "${S3_ENDPOINT:-s3.amazonaws.com}"
|
|
region: "${S3_REGION:-us-east-1}"
|
|
access_key: "${S3_ACCESS_KEY}"
|
|
secret_key: "${S3_SECRET_KEY}"
|
|
bucket: "${S3_BUCKET}"
|
|
public_url: "https://${CLOUDRON_APP_FQDN}/photos"
|
|
EOF
|
|
chmod 600 ${SERVER_DIR}/museum.yaml
|
|
echo "==> Created museum.yaml configuration"
|
|
else
|
|
echo "==> museum.yaml configuration already exists"
|
|
fi
|
|
|
|
# Test PostgreSQL connectivity
|
|
echo "==> Testing PostgreSQL connectivity..."
|
|
if ! PGPASSWORD="$CLOUDRON_POSTGRESQL_PASSWORD" psql -h "$CLOUDRON_POSTGRESQL_HOST" -p "$CLOUDRON_POSTGRESQL_PORT" -U "$CLOUDRON_POSTGRESQL_USERNAME" -d "$CLOUDRON_POSTGRESQL_DATABASE" -c "SELECT 1;" > /dev/null 2>&1; then
|
|
echo "==> ERROR: Failed to connect to PostgreSQL"
|
|
echo "==> Connection details:"
|
|
echo "==> Host: $CLOUDRON_POSTGRESQL_HOST"
|
|
echo "==> Port: $CLOUDRON_POSTGRESQL_PORT"
|
|
echo "==> User: $CLOUDRON_POSTGRESQL_USERNAME"
|
|
echo "==> Database: $CLOUDRON_POSTGRESQL_DATABASE"
|
|
else
|
|
echo "==> PostgreSQL connection successful"
|
|
fi
|
|
|
|
# Download and set up web app
|
|
echo "==> Setting up Ente web app..."
|
|
WEB_DIR="/app/data/ente/web"
|
|
if [ ! -d "${WEB_DIR}/photos" ] || [ ! -f "${WEB_DIR}/photos/index.html" ]; then
|
|
# Create placeholder HTML
|
|
echo "==> Downloading Ente web app..."
|
|
|
|
# Try to download web app
|
|
if curl -L -o /tmp/web.zip "https://github.com/ente-io/ente/releases/latest/download/web.zip" 2>/app/data/logs/curl_web.log; then
|
|
echo "==> Web app download successful, extracting..."
|
|
# Check if it's a valid zip file
|
|
if file /tmp/web.zip | grep -q "Zip archive data"; then
|
|
mkdir -p /tmp/web
|
|
unzip -o /tmp/web.zip -d /tmp/web
|
|
# Check if extraction was successful
|
|
if [ -d "/tmp/web" ]; then
|
|
# Copy contents to the web directory
|
|
cp -r /tmp/web/* ${WEB_DIR}/
|
|
echo "==> Web app extracted and installed"
|
|
else
|
|
echo "==> Failed to extract web app"
|
|
fi
|
|
else
|
|
echo "==> Downloaded file is not a valid zip file: $(file /tmp/web.zip)"
|
|
fi
|
|
else
|
|
echo "==> Web app download failed, trying with wget..."
|
|
if wget -O /tmp/web.zip "https://github.com/ente-io/ente/releases/latest/download/web.zip" 2>/app/data/logs/wget_web.log; then
|
|
echo "==> Web app download with wget successful, extracting..."
|
|
# Check if it's a valid zip file
|
|
if file /tmp/web.zip | grep -q "Zip archive data"; then
|
|
mkdir -p /tmp/web
|
|
unzip -o /tmp/web.zip -d /tmp/web
|
|
# Copy contents to the web directory
|
|
cp -r /tmp/web/* ${WEB_DIR}/
|
|
echo "==> Web app extracted and installed"
|
|
else
|
|
echo "==> Downloaded file is not a valid zip file: $(file /tmp/web.zip)"
|
|
fi
|
|
else
|
|
echo "==> Web app download with wget also failed, creating placeholders"
|
|
fi
|
|
fi
|
|
|
|
# Create placeholder HTML if download failed
|
|
if [ ! -f "${WEB_DIR}/photos/index.html" ]; then
|
|
echo "==> Creating placeholder HTML files..."
|
|
mkdir -p ${WEB_DIR}/photos
|
|
cat > ${WEB_DIR}/photos/index.html << 'EOF'
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Ente Photos</title>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<style>
|
|
body { font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }
|
|
.container { max-width: 600px; margin: 0 auto; padding: 20px; }
|
|
h1 { color: #333; }
|
|
p { color: #666; }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div class="container">
|
|
<h1>Ente Photos</h1>
|
|
<p>This is a placeholder for the Ente Photos application. The actual app is being set up.</p>
|
|
</div>
|
|
</body>
|
|
</html>
|
|
EOF
|
|
# Create similar placeholders for other apps
|
|
mkdir -p ${WEB_DIR}/accounts
|
|
cp ${WEB_DIR}/photos/index.html ${WEB_DIR}/accounts/index.html
|
|
sed -i 's/Photos/Accounts/g' ${WEB_DIR}/accounts/index.html
|
|
|
|
mkdir -p ${WEB_DIR}/auth
|
|
cp ${WEB_DIR}/photos/index.html ${WEB_DIR}/auth/index.html
|
|
sed -i 's/Photos/Auth/g' ${WEB_DIR}/auth/index.html
|
|
|
|
mkdir -p ${WEB_DIR}/cast
|
|
cp ${WEB_DIR}/photos/index.html ${WEB_DIR}/cast/index.html
|
|
sed -i 's/Photos/Cast/g' ${WEB_DIR}/cast/index.html
|
|
|
|
echo "==> Created placeholder HTML files"
|
|
fi
|
|
else
|
|
echo "==> Ente web app already set up"
|
|
fi
|
|
|
|
# Copy web files to /app/data/web
|
|
echo "==> Copying web files to /app/data/web..."
|
|
if [ -d "${WEB_DIR}/photos" ]; then
|
|
cp -r ${WEB_DIR}/photos/* /app/data/web/photos/ || echo "==> Warning: Failed to copy photos files"
|
|
fi
|
|
if [ -d "${WEB_DIR}/accounts" ]; then
|
|
cp -r ${WEB_DIR}/accounts/* /app/data/web/accounts/ || echo "==> Warning: Failed to copy accounts files"
|
|
fi
|
|
if [ -d "${WEB_DIR}/auth" ]; then
|
|
cp -r ${WEB_DIR}/auth/* /app/data/web/auth/ || echo "==> Warning: Failed to copy auth files"
|
|
fi
|
|
if [ -d "${WEB_DIR}/cast" ]; then
|
|
cp -r ${WEB_DIR}/cast/* /app/data/web/cast/ || echo "==> Warning: Failed to copy cast files"
|
|
fi
|
|
|
|
# Create runtime config for web app
|
|
echo "==> Creating runtime config for web app..."
|
|
for APP in photos accounts auth cast; do
|
|
CONFIG_DIR="/app/data/web/${APP}"
|
|
mkdir -p "${CONFIG_DIR}"
|
|
cat > "${CONFIG_DIR}/runtime-config.js" << EOF
|
|
window.RUNTIME_CONFIG = {
|
|
API_URL: "https://${CLOUDRON_APP_FQDN}/api",
|
|
PUBLIC_ALBUMS_URL: "https://${CLOUDRON_APP_FQDN}/public",
|
|
DEBUG: true
|
|
};
|
|
console.log("Loaded runtime config:", window.RUNTIME_CONFIG);
|
|
EOF
|
|
echo "==> Created runtime config for ${APP}"
|
|
done
|
|
|
|
# Set up Caddy web server
|
|
echo "==> Setting up Caddy web server..."
|
|
cat > /app/data/Caddyfile << EOF
|
|
:3080 {
|
|
log {
|
|
output file /app/data/logs/caddy.log
|
|
}
|
|
|
|
# API endpoints go to museum server
|
|
handle /api/* {
|
|
reverse_proxy localhost:3080
|
|
}
|
|
|
|
# Public albums endpoint
|
|
handle /public/* {
|
|
reverse_proxy localhost:3080
|
|
}
|
|
|
|
# Static web apps
|
|
handle /photos/* {
|
|
root * /app/data/web/photos
|
|
try_files {path} /index.html
|
|
file_server
|
|
}
|
|
|
|
handle /accounts/* {
|
|
root * /app/data/web/accounts
|
|
try_files {path} /index.html
|
|
file_server
|
|
}
|
|
|
|
handle /auth/* {
|
|
root * /app/data/web/auth
|
|
try_files {path} /index.html
|
|
file_server
|
|
}
|
|
|
|
handle /cast/* {
|
|
root * /app/data/web/cast
|
|
try_files {path} /index.html
|
|
file_server
|
|
}
|
|
|
|
# Redirect root to photos
|
|
handle {
|
|
redir / /photos/
|
|
}
|
|
}
|
|
EOF
|
|
echo "==> Created Caddy configuration"
|
|
|
|
# Start museum server or placeholder
|
|
cd ${SERVER_DIR}
|
|
if [ -f "${SERVER_DIR}/museum" ] && [ -x "${SERVER_DIR}/museum" ]; then
|
|
echo "==> Starting Museum server..."
|
|
mkdir -p /app/data/logs
|
|
./museum serve --config museum.yaml > /app/data/logs/museum.log 2>&1 &
|
|
|
|
# Wait for server to start
|
|
MAX_ATTEMPTS=30
|
|
ATTEMPT=0
|
|
while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
|
|
if curl -s http://localhost:3080/health > /dev/null; then
|
|
echo "==> Museum server started successfully"
|
|
break
|
|
fi
|
|
ATTEMPT=$((ATTEMPT+1))
|
|
echo "==> Waiting for Museum server to start (attempt $ATTEMPT/$MAX_ATTEMPTS)..."
|
|
sleep 1
|
|
done
|
|
|
|
if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
|
|
echo "==> ERROR: Museum server failed to start within $MAX_ATTEMPTS seconds"
|
|
echo "==> Last few lines of museum.log:"
|
|
tail -n 20 /app/data/logs/museum.log || echo "==> No log file found"
|
|
|
|
# Fall back to Node.js server if available
|
|
if [ -f "${SERVER_DIR}/server.js" ]; then
|
|
echo "==> Starting Node.js placeholder server..."
|
|
node ${SERVER_DIR}/server.js >> /app/data/logs/museum.log 2>&1 &
|
|
|
|
# Wait for server to start
|
|
MAX_ATTEMPTS=10
|
|
ATTEMPT=0
|
|
while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
|
|
if curl -s http://localhost:3080/health > /dev/null; then
|
|
echo "==> Node.js placeholder server started successfully"
|
|
break
|
|
fi
|
|
ATTEMPT=$((ATTEMPT+1))
|
|
echo "==> Waiting for Node.js server to start (attempt $ATTEMPT/$MAX_ATTEMPTS)..."
|
|
sleep 1
|
|
done
|
|
|
|
if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
|
|
echo "==> ERROR: Node.js server failed to start within $MAX_ATTEMPTS seconds"
|
|
echo "==> The application will have limited API functionality"
|
|
fi
|
|
else
|
|
echo "==> No fallback server available. Creating one on the fly..."
|
|
# Create a minimal Node.js server
|
|
cat > ${SERVER_DIR}/server.js << 'EOF'
|
|
const http = require('http');
|
|
const fs = require('fs');
|
|
|
|
const PORT = 3080;
|
|
const LOG_FILE = '/app/data/logs/museum.log';
|
|
|
|
// Ensure log directory exists
|
|
if (!fs.existsSync('/app/data/logs')) {
|
|
fs.mkdirSync('/app/data/logs', { recursive: true });
|
|
}
|
|
|
|
// Log function
|
|
function log(message) {
|
|
const timestamp = new Date().toISOString();
|
|
const logMessage = `${timestamp} - ${message}\n`;
|
|
console.log(logMessage);
|
|
fs.appendFileSync(LOG_FILE, logMessage);
|
|
}
|
|
|
|
// Create server
|
|
const server = http.createServer((req, res) => {
|
|
log(`Request received: ${req.method} ${req.url}`);
|
|
|
|
// Health check endpoint
|
|
if (req.url === '/health' || req.url === '/api/health') {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ status: 'OK', server: 'Museum Placeholder' }));
|
|
return;
|
|
}
|
|
|
|
// Default response for any other endpoint
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ message: 'Placeholder Museum Server' }));
|
|
});
|
|
|
|
// Start server
|
|
server.listen(PORT, '0.0.0.0', () => {
|
|
log(`Minimal museum placeholder server running on port ${PORT}`);
|
|
});
|
|
EOF
|
|
node ${SERVER_DIR}/server.js >> /app/data/logs/museum.log 2>&1 &
|
|
echo "==> Started minimal Node.js placeholder server"
|
|
fi
|
|
fi
|
|
elif [ -f "${SERVER_DIR}/server.js" ]; then
|
|
echo "==> Starting Node.js placeholder server..."
|
|
node ${SERVER_DIR}/server.js > /app/data/logs/museum.log 2>&1 &
|
|
echo "==> Node.js placeholder server started"
|
|
else
|
|
echo "==> ERROR: No server executable found"
|
|
exit 1
|
|
fi
|
|
|
|
# Start Caddy web server
|
|
echo "==> Starting Caddy web server..."
|
|
caddy run --config /app/data/Caddyfile > /app/data/logs/caddy.log 2>&1 &
|
|
echo "==> Caddy web server started"
|
|
|
|
# Keep script running
|
|
echo "==> Setup complete, entering wait loop..."
|
|
tail -f /app/data/logs/museum.log |