Ente $app_name
Status: The Ente server is being configured.
This is the Ente $app_name application running on your Cloudron. To complete the setup:
- Configure your S3 storage in
/app/data/s3.env
- Ensure the Museum server is properly running
- You might need to restart the app after configuration changes
GitHub Repository ·
Documentation
EOF
# Create runtime config
cat > "$app_dir/runtime-config.js" << EOF
window.RUNTIME_CONFIG = {
API_URL: "/api",
PUBLIC_ALBUMS_URL: "/public",
DEBUG: true
};
console.log("Loaded Ente runtime config:", window.RUNTIME_CONFIG);
EOF
log "INFO" "Created placeholder for $app_name app"
}
# Create placeholder pages for each app if they don't exist
for APP in photos accounts auth cast; do
if [ ! -f "/app/data/web/$APP/index.html" ]; then
create_placeholder_page "$APP"
fi
done
# ===============================================
# Node.js Placeholder Server
# ===============================================
create_nodejs_placeholder() {
log "INFO" "Creating Node.js placeholder server"
# Create server script
cat > "/app/data/ente/server/placeholder.js" << 'EOF'
const http = require('http');
const fs = require('fs');
const { execSync } = require('child_process');
const path = require('path');
const PORT = 3080;
const LOG_FILE = '/app/data/logs/museum.log';
const DB_SCHEMA_FILE = '/app/data/ente/server/schema.sql';
// Log function
function log(message) {
const timestamp = new Date().toISOString();
const logMessage = `${timestamp} - ${message}\n`;
console.log(logMessage);
try {
fs.appendFileSync(LOG_FILE, logMessage);
} catch (err) {
console.error(`Error writing to log: ${err.message}`);
}
}
log('Starting Ente placeholder server...');
// Try to initialize the database schema
function initializeDatabase() {
try {
// Create a basic schema file if it doesn't exist
if (!fs.existsSync(DB_SCHEMA_FILE)) {
log('Creating basic database schema file');
const basicSchema = `
-- Basic schema for Ente Museum server
CREATE TABLE IF NOT EXISTS users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL,
created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE IF NOT EXISTS files (
id SERIAL PRIMARY KEY,
user_id INTEGER REFERENCES users(id),
filename VARCHAR(255) NOT NULL,
path VARCHAR(255) NOT NULL,
mime_type VARCHAR(100),
size BIGINT,
created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);
`;
fs.writeFileSync(DB_SCHEMA_FILE, basicSchema);
}
// Initialize database
const dbUser = process.env.CLOUDRON_POSTGRESQL_USERNAME;
const dbPassword = process.env.CLOUDRON_POSTGRESQL_PASSWORD;
const dbHost = process.env.CLOUDRON_POSTGRESQL_HOST;
const dbPort = process.env.CLOUDRON_POSTGRESQL_PORT;
const dbName = process.env.CLOUDRON_POSTGRESQL_DATABASE;
if (dbUser && dbPassword && dbHost && dbPort && dbName) {
log(`Initializing database ${dbName} on ${dbHost}:${dbPort}`);
const command = `PGPASSWORD="${dbPassword}" psql -h "${dbHost}" -p "${dbPort}" -U "${dbUser}" -d "${dbName}" -f "${DB_SCHEMA_FILE}"`;
execSync(command, { stdio: 'inherit' });
log('Database initialized successfully');
return true;
} else {
log('Database environment variables not set, skipping initialization');
return false;
}
} catch (err) {
log(`Error initializing database: ${err.message}`);
return false;
}
}
// Try to initialize database
initializeDatabase();
// API response handlers
const apiHandlers = {
// Health check endpoint
'/health': (req, res) => {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({
status: 'OK',
server: 'Ente Placeholder',
version: '1.0.0'
}));
log('Health check request - responded with status OK');
},
// User verification endpoint
'/api/users/verify': (req, res) => {
res.writeHead(200, { 'Content-Type': 'application/json' });
log('User verify request - responding with success');
res.end(JSON.stringify({
success: true,
isValidEmail: true,
isAvailable: true,
isVerified: true,
canCreateAccount: true
}));
},
// User login endpoint
'/api/users/login': (req, res) => {
if (req.method === 'POST') {
let body = '';
req.on('data', chunk => {
body += chunk.toString();
});
req.on('end', () => {
log('Login request received');
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({
success: true,
token: 'placeholder-jwt-token-' + Date.now(),
user: {
id: 1,
email: 'placeholder@example.com',
name: 'Placeholder User'
}
}));
});
} else {
res.writeHead(405, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({
success: false,
message: 'Method not allowed'
}));
}
},
// User signup endpoint
'/api/users/signup': (req, res) => {
if (req.method === 'POST') {
let body = '';
req.on('data', chunk => {
body += chunk.toString();
});
req.on('end', () => {
log('Signup request received');
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({
success: true,
token: 'placeholder-jwt-token-' + Date.now(),
user: {
id: 1,
email: 'placeholder@example.com',
name: 'New User'
}
}));
});
} else {
res.writeHead(405, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({
success: false,
message: 'Method not allowed'
}));
}
},
// Files endpoint
'/api/files': (req, res) => {
res.writeHead(200, { 'Content-Type': 'application/json' });
log('Files request - responding with empty list');
res.end(JSON.stringify({
success: true,
files: []
}));
},
// Collections endpoint
'/api/collections': (req, res) => {
res.writeHead(200, { 'Content-Type': 'application/json' });
log('Collections request - responding with empty list');
res.end(JSON.stringify({
success: true,
collections: []
}));
},
// Default API handler
'default': (req, res) => {
res.writeHead(200, { 'Content-Type': 'application/json' });
log(`API request to ${req.url} - responding with generic success`);
res.end(JSON.stringify({
success: true,
message: 'Placeholder API response',
path: req.url
}));
}
};
// Create server
const server = http.createServer((req, res) => {
log(`Request received: ${req.method} ${req.url}`);
// Set CORS headers for all responses
res.setHeader('Access-Control-Allow-Origin', '*');
res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type,Authorization');
// Handle OPTIONS request (for CORS preflight)
if (req.method === 'OPTIONS') {
res.writeHead(200);
res.end();
return;
}
// Handle health check endpoint
if (req.url === '/health' || req.url === '/api/health') {
apiHandlers['/health'](req, res);
return;
}
// Handle paths that exactly match defined endpoints
if (apiHandlers[req.url]) {
apiHandlers[req.url](req, res);
return;
}
// Route based on URL pattern
if (req.url.startsWith('/api/')) {
const handler = apiHandlers['default'];
handler(req, res);
return;
}
// Default response for any other endpoint
res.writeHead(200, { 'Content-Type': 'application/json' });
log(`Unknown request to ${req.url} - responding with default message`);
res.end(JSON.stringify({
message: 'Ente Placeholder Server',
path: req.url,
server: 'Node.js Placeholder'
}));
});
// Start server
try {
server.listen(PORT, '0.0.0.0', () => {
log(`Ente placeholder server running on port ${PORT}`);
log(`Server is listening at http://0.0.0.0:${PORT}`);
});
} catch (err) {
log(`Failed to start server: ${err.message}`);
process.exit(1);
}
// Handle errors
server.on('error', (error) => {
log(`Server error: ${error.message}`);
if (error.code === 'EADDRINUSE') {
log('Address already in use, retrying in 5 seconds...');
setTimeout(() => {
server.close();
server.listen(PORT, '0.0.0.0');
}, 5000);
}
});
log('Ente placeholder server initialization complete');
EOF
# Start the Node.js placeholder server
log "INFO" "Starting Node.js placeholder server"
cd /app/data/ente/server
node placeholder.js > "$MUSEUM_LOG" 2>&1 &
PLACEHOLDER_PID=$!
log "INFO" "Started Node.js server with PID: $PLACEHOLDER_PID"
# Wait for the server to start
MAX_ATTEMPTS=30
ATTEMPT=0
SUCCESS=false
while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
if curl -s http://localhost:3080/health > /dev/null 2>&1; then
log "INFO" "Node.js placeholder server started successfully"
SUCCESS=true
break
fi
ATTEMPT=$((ATTEMPT+1))
log "INFO" "Waiting for server to start (attempt $ATTEMPT/$MAX_ATTEMPTS)"
sleep 1
done
if [ "$SUCCESS" = false ]; then
log "ERROR" "Node.js placeholder server failed to start"
log "ERROR" "Last 20 lines of log:"
tail -n 20 "$MUSEUM_LOG" | while read -r line; do
log "ERROR" " $line"
done
return 1
fi
return 0
}
# ===============================================
# Start the appropriate server
# ===============================================
log "INFO" "Starting server"
if [ "$USE_PLACEHOLDER" = true ]; then
log "INFO" "Using Node.js placeholder server"
create_nodejs_placeholder
else
log "INFO" "Starting actual Museum server"
cd /app/data/ente/server
"$MUSEUM_BIN" --config "$MUSEUM_CONFIG" > "$MUSEUM_LOG" 2>&1 &
MUSEUM_PID=$!
log "INFO" "Started Museum server with PID: $MUSEUM_PID"
# Wait for the server to start
MAX_ATTEMPTS=30
ATTEMPT=0
SUCCESS=false
while [ $ATTEMPT -lt $MAX_ATTEMPTS ]; do
if curl -s http://localhost:3080/health > /dev/null 2>&1; then
log "INFO" "Museum server started successfully"
SUCCESS=true
break
fi
ATTEMPT=$((ATTEMPT+1))
log "INFO" "Waiting for Museum server to start (attempt $ATTEMPT/$MAX_ATTEMPTS)"
sleep 1
done
if [ "$SUCCESS" = false ]; then
log "ERROR" "Museum server failed to start within $MAX_ATTEMPTS seconds"
log "ERROR" "Last 20 lines of museum.log:"
tail -n 20 "$MUSEUM_LOG" | while read -r line; do
log "ERROR" " $line"
done
log "WARN" "Falling back to Node.js placeholder server"
create_nodejs_placeholder
fi
fi
# ===============================================
# Setup Caddy web server
# ===============================================
log "INFO" "Setting up Caddy web server"
# Create Caddy configuration
CADDY_CONFIG="/app/data/Caddyfile"
cat > "$CADDY_CONFIG" << EOF
:3080 {
log {
output file /app/data/logs/caddy.log
}
# API endpoints
handle /api/* {
reverse_proxy localhost:3080
}
# Public albums endpoint
handle /public/* {
reverse_proxy localhost:3080
}
# Health check endpoint
handle /health {
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
log "INFO" "Starting Caddy web server"
caddy run --config "$CADDY_CONFIG" > /app/data/logs/caddy.log 2>&1 &
CADDY_PID=$!
log "INFO" "Caddy web server started with PID: $CADDY_PID"
# ===============================================
# Finalization and monitoring
# ===============================================
log "INFO" "Setup complete"
# Create startup instructions
cat > /app/data/SETUP-INSTRUCTIONS.md << EOF
# Ente Cloudron App - Setup Instructions
## Configuration
1. **S3 Storage**: Edit the configuration file at \`/app/data/s3.env\` with your S3-compatible storage credentials.
2. **Museum Server**: The server configuration is at \`/app/data/ente/server/museum.yaml\` if you need to customize settings.
## Troubleshooting
- **Logs**: Check the logs at \`/app/data/logs/\` for any issues.
- **Restart**: If you change configuration, restart the app to apply changes.
## Web Applications
The following web applications are available:
- Photos: https://${CLOUDRON_APP_FQDN}/photos/
- Accounts: https://${CLOUDRON_APP_FQDN}/accounts/
- Auth: https://${CLOUDRON_APP_FQDN}/auth/
- Cast: https://${CLOUDRON_APP_FQDN}/cast/
## Support
For more information, visit the [Ente GitHub repository](https://github.com/ente-io/ente).
EOF
# Remove startup flag
rm -f /app/data/startup_in_progress
# Verify running services
log "INFO" "Verifying running services"
if ps aux | grep -E "museum|placeholder" | grep -v grep > /dev/null; then
log "INFO" "Server is running"
else
log "ERROR" "No server is running!"
fi
if ps aux | grep caddy | grep -v grep > /dev/null; then
log "INFO" "Caddy server is running"
else
log "ERROR" "Caddy server is not running!"
fi
log "INFO" "Ente Cloudron app startup complete"
# Keep the script running to prevent container exit
exec tail -f "$MUSEUM_LOG"