546 lines
17 KiB
JavaScript
546 lines
17 KiB
JavaScript
/**
|
|
* ApsGo Railway Worker
|
|
* Background service untuk automation scheduling 24/7
|
|
* Features:
|
|
* - Waktu Mode: Scheduled watering by time
|
|
* - Sensor Mode: Automatic watering by soil moisture threshold
|
|
* - Redis Queue: Prevent race conditions & concurrent task management
|
|
* - Firebase Realtime DB: Sync dengan Flutter app dan ESP32
|
|
*/
|
|
|
|
require('dotenv').config();
|
|
const admin = require('firebase-admin');
|
|
const { Queue, Worker } = require('bullmq');
|
|
const Redis = require('ioredis');
|
|
const cron = require('cron');
|
|
|
|
// ==================== CONFIGURATION ====================
|
|
|
|
// Set timezone untuk Indonesia (UTC+7)
|
|
process.env.TZ = process.env.TZ || 'Asia/Jakarta';
|
|
|
|
const config = {
|
|
redis: {
|
|
host: process.env.REDIS_HOST || 'localhost',
|
|
port: parseInt(process.env.REDIS_PORT) || 6379,
|
|
password: process.env.REDIS_PASSWORD || undefined,
|
|
maxRetriesPerRequest: null, // Required for BullMQ
|
|
},
|
|
firebase: {
|
|
projectId: process.env.FIREBASE_PROJECT_ID,
|
|
clientEmail: process.env.FIREBASE_CLIENT_EMAIL,
|
|
privateKey: process.env.FIREBASE_PRIVATE_KEY?.replace(/\\n/g, '\n'),
|
|
databaseURL: process.env.FIREBASE_DATABASE_URL,
|
|
},
|
|
worker: {
|
|
concurrency: 1, // Process 1 job at a time (prevent race condition)
|
|
checkInterval: 60000, // Check jadwal setiap 60 detik (reduced from 30s)
|
|
sensorDebounce: 120000, // 2 menit minimum antar penyiraman per pot
|
|
},
|
|
};
|
|
|
|
console.log('🚀 Starting ApsGo Railway Worker...');
|
|
console.log(`📡 Firebase Project: ${config.firebase.projectId}`);
|
|
console.log(`📦 Redis: ${config.redis.host}:${config.redis.port}`);
|
|
console.log(`⏰ Timezone: ${process.env.TZ} (Current: ${new Date().toLocaleString('id-ID', {timeZone: 'Asia/Jakarta'})})`);
|
|
|
|
// ==================== ENVIRONMENT VALIDATION ====================
|
|
|
|
const requiredEnvs = [
|
|
'FIREBASE_PROJECT_ID',
|
|
'FIREBASE_CLIENT_EMAIL',
|
|
'FIREBASE_PRIVATE_KEY',
|
|
'FIREBASE_DATABASE_URL'
|
|
];
|
|
|
|
const missingEnvs = requiredEnvs.filter(env => !process.env[env]);
|
|
if (missingEnvs.length > 0) {
|
|
console.error('❌ Missing required environment variables:');
|
|
missingEnvs.forEach(env => console.error(` - ${env}`));
|
|
console.error('\n📋 To fix this:');
|
|
console.error('1. Go to Railway Dashboard');
|
|
console.error('2. Select your worker service');
|
|
console.error('3. Go to Variables tab');
|
|
console.error('4. Add the missing variables');
|
|
console.error('5. Redeploy');
|
|
process.exit(1);
|
|
}
|
|
|
|
console.log('✅ All required environment variables are set');
|
|
|
|
// ==================== FIREBASE INITIALIZATION ====================
|
|
|
|
// Suppress Firebase warnings in production
|
|
if (process.env.NODE_ENV === 'production' || process.env.RAILWAY_ENVIRONMENT) {
|
|
process.env.FIREBASE_AUTH_EMULATOR_HOST = undefined;
|
|
process.env.FIRESTORE_EMULATOR_HOST = undefined;
|
|
}
|
|
|
|
try {
|
|
admin.initializeApp({
|
|
credential: admin.credential.cert({
|
|
projectId: config.firebase.projectId,
|
|
clientEmail: config.firebase.clientEmail,
|
|
privateKey: config.firebase.privateKey,
|
|
}),
|
|
databaseURL: config.firebase.databaseURL,
|
|
});
|
|
console.log('✅ Firebase Admin initialized');
|
|
} catch (error) {
|
|
console.error('❌ Firebase initialization failed:', error.message);
|
|
process.exit(1);
|
|
}
|
|
|
|
const db = admin.database();
|
|
|
|
// Add error handlers for Firebase database
|
|
db.ref('.info/connected').on('value', (snap) => {
|
|
if (snap.val() === true) {
|
|
console.log('🔌 Firebase realtime connection active');
|
|
}
|
|
});
|
|
|
|
// Suppress Firebase internal warnings by catching errors
|
|
process.on('warning', (warning) => {
|
|
// Suppress specific Firebase warnings but log others
|
|
if (!warning.message?.includes('firebase/database')) {
|
|
console.warn('⚠️ Warning:', warning.message);
|
|
}
|
|
});
|
|
|
|
// ==================== REDIS & QUEUE SETUP ====================
|
|
|
|
const redis = new Redis(config.redis);
|
|
const wateringQueue = new Queue('watering', { connection: redis });
|
|
|
|
redis.on('connect', () => console.log('✅ Redis connected'));
|
|
redis.on('error', (err) => console.error('❌ Redis error:', err.message));
|
|
|
|
// Track last watering time untuk prevent spam
|
|
const lastWateringTime = {};
|
|
|
|
// ==================== WATERING WORKER ====================
|
|
|
|
const wateringWorker = new Worker(
|
|
'watering',
|
|
async (job) => {
|
|
const { type, potNumbers, pompaAir, pompaPupuk, duration, scheduleId } = job.data;
|
|
|
|
console.log(`\n💧 Processing Job: ${job.id}`);
|
|
console.log(` Type: ${type}`);
|
|
console.log(` Pots: [${potNumbers.join(', ')}]`);
|
|
console.log(` Duration: ${duration}s`);
|
|
|
|
try {
|
|
// Prepare aktuator updates
|
|
const updates = {};
|
|
if (pompaAir) updates['mosvet_1'] = true;
|
|
if (pompaPupuk) updates['mosvet_2'] = true;
|
|
|
|
// Turn ON valves for selected pots
|
|
for (const pot of potNumbers) {
|
|
if (pot >= 1 && pot <= 5) {
|
|
updates[`mosvet_${pot + 2}`] = true; // pot 1 → mosvet_3, etc.
|
|
}
|
|
}
|
|
|
|
// Turn ON
|
|
console.log(' 🔛 Turning ON:', Object.keys(updates).join(', '));
|
|
await db.ref('aktuator').update(updates);
|
|
|
|
// Wait for duration with progress logging
|
|
const startTime = Date.now();
|
|
const endTime = startTime + duration * 1000;
|
|
|
|
while (Date.now() < endTime) {
|
|
const remaining = Math.ceil((endTime - Date.now()) / 1000);
|
|
if (remaining % 10 === 0 || remaining <= 5) {
|
|
console.log(` ⏳ ${remaining}s remaining...`);
|
|
}
|
|
await sleep(1000);
|
|
}
|
|
|
|
// Turn OFF
|
|
const offUpdates = {};
|
|
for (const key in updates) {
|
|
offUpdates[key] = false;
|
|
}
|
|
console.log(' 🔴 Turning OFF');
|
|
await db.ref('aktuator').update(offUpdates);
|
|
|
|
// Log history
|
|
await logHistory(type, potNumbers, duration);
|
|
|
|
// Update last watering time
|
|
for (const pot of potNumbers) {
|
|
lastWateringTime[`pot_${pot}`] = Date.now();
|
|
}
|
|
|
|
console.log(` ✅ Job completed successfully`);
|
|
return { success: true, duration, pots: potNumbers };
|
|
} catch (error) {
|
|
console.error(` ❌ Job failed:`, error.message);
|
|
|
|
// Safety: Turn OFF everything
|
|
try {
|
|
await db.ref('aktuator').update({
|
|
mosvet_1: false,
|
|
mosvet_2: false,
|
|
mosvet_3: false,
|
|
mosvet_4: false,
|
|
mosvet_5: false,
|
|
mosvet_6: false,
|
|
mosvet_7: false,
|
|
mosvet_8: false, // Pengaduk
|
|
});
|
|
console.log(' 🛡️ Safety: All aktuators turned OFF');
|
|
} catch (safetyError) {
|
|
console.error(' ⚠️ Safety OFF failed:', safetyError.message);
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
},
|
|
{
|
|
connection: redis,
|
|
concurrency: config.worker.concurrency,
|
|
removeOnComplete: { count: 100 }, // Keep last 100 completed jobs
|
|
removeOnFail: { count: 50 }, // Keep last 50 failed jobs
|
|
}
|
|
);
|
|
|
|
wateringWorker.on('completed', (job) => {
|
|
console.log(`✅ Worker completed job ${job.id}`);
|
|
});
|
|
|
|
wateringWorker.on('failed', (job, err) => {
|
|
console.error(`❌ Worker failed job ${job?.id}:`, err.message);
|
|
});
|
|
|
|
// ==================== WAKTU MODE (TIME SCHEDULER) ====================
|
|
|
|
let lastScheduleCheck = {};
|
|
|
|
async function checkScheduledWatering() {
|
|
try {
|
|
const snapshot = await db.ref('kontrol').once('value');
|
|
const kontrolConfig = snapshot.val();
|
|
|
|
if (!kontrolConfig || !kontrolConfig.waktu) {
|
|
// Waktu mode disabled - no log to reduce noise
|
|
return;
|
|
}
|
|
|
|
const now = new Date();
|
|
const currentTime = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
|
|
const dateKey = `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, '0')}-${now.getDate().toString().padStart(2, '0')}`;
|
|
if (kontrolConfig.waktu_1 && kontrolConfig.waktu_1 === currentTime) {
|
|
const scheduleKey = `jadwal_1_${dateKey}_${currentTime}`;
|
|
|
|
if (!lastScheduleCheck[scheduleKey]) {
|
|
console.log(`\n🕐 JADWAL 1 TRIGGERED: ${currentTime}`);
|
|
|
|
await wateringQueue.add(
|
|
'schedule-1',
|
|
{
|
|
type: 'waktu_jadwal_1',
|
|
potNumbers: [1, 2, 3, 4, 5], // All pots
|
|
pompaAir: true,
|
|
pompaPupuk: true,
|
|
duration: kontrolConfig.durasi_1 || 60,
|
|
scheduleId: scheduleKey,
|
|
},
|
|
{
|
|
jobId: scheduleKey,
|
|
removeOnComplete: true,
|
|
}
|
|
);
|
|
|
|
lastScheduleCheck[scheduleKey] = true;
|
|
console.log(` 📌 Added to queue: ${scheduleKey}`);
|
|
}
|
|
}
|
|
|
|
// Check Jadwal 2
|
|
if (kontrolConfig.waktu_2 && kontrolConfig.waktu_2 === currentTime) {
|
|
const scheduleKey = `jadwal_2_${dateKey}_${currentTime}`;
|
|
|
|
if (!lastScheduleCheck[scheduleKey]) {
|
|
console.log(`\n🕑 JADWAL 2 TRIGGERED: ${currentTime}`);
|
|
|
|
await wateringQueue.add(
|
|
'schedule-2',
|
|
{
|
|
type: 'waktu_jadwal_2',
|
|
potNumbers: [1, 2, 3, 4, 5], // All pots
|
|
pompaAir: true,
|
|
pompaPupuk: true,
|
|
duration: kontrolConfig.durasi_2 || 60,
|
|
scheduleId: scheduleKey,
|
|
},
|
|
{
|
|
jobId: scheduleKey,
|
|
removeOnComplete: true,
|
|
}
|
|
);
|
|
|
|
lastScheduleCheck[scheduleKey] = true;
|
|
console.log(` 📌 Added to queue: ${scheduleKey}`);
|
|
}
|
|
}
|
|
|
|
// Cleanup old schedule checks (> 2 menit)
|
|
const twoMinutesAgo = Date.now() - 120000;
|
|
for (const key in lastScheduleCheck) {
|
|
if (key.includes(dateKey)) continue; // Keep today's
|
|
delete lastScheduleCheck[key];
|
|
}
|
|
} catch (error) {
|
|
console.error('❌ Error checking scheduled watering:', error.message);
|
|
}
|
|
}
|
|
|
|
// Run check setiap 60 detik
|
|
setInterval(checkScheduledWatering, config.worker.checkInterval);
|
|
console.log(`✅ Waktu Mode scheduler started (check every ${config.worker.checkInterval / 1000}s)`);
|
|
|
|
// ==================== SENSOR MODE (THRESHOLD MONITORING) ====================
|
|
|
|
async function setupSensorMonitoring() {
|
|
console.log('✅ Sensor Mode monitoring started');
|
|
|
|
db.ref('data').on('value', async (snapshot) => {
|
|
try {
|
|
const sensorData = snapshot.val();
|
|
if (!sensorData) return;
|
|
|
|
const configSnapshot = await db.ref('kontrol').once('value');
|
|
const kontrolConfig = configSnapshot.val();
|
|
|
|
if (!kontrolConfig || !kontrolConfig.otomatis) {
|
|
// Sensor mode disabled
|
|
return;
|
|
}
|
|
|
|
const batasBawah = kontrolConfig.batas_bawah || 40;
|
|
const batasAtas = kontrolConfig.batas_atas || 100;
|
|
const durasiSensor = kontrolConfig.durasi_sensor || 60;
|
|
const modeSensor = kontrolConfig.mode_sensor || 'fixed'; // 'fixed' or 'smart'
|
|
|
|
// Check each pot
|
|
for (let i = 1; i <= 5; i++) {
|
|
const soilKey = `soil_${i}`;
|
|
const soilValue = parseInt(sensorData[soilKey]) || 0;
|
|
|
|
if (soilValue < batasBawah) {
|
|
const potKey = `pot_${i}`;
|
|
const lastTime = lastWateringTime[potKey];
|
|
|
|
// Debounce: minimum 2 menit antar penyiraman
|
|
if (lastTime && Date.now() - lastTime < config.worker.sensorDebounce) {
|
|
const remainingSeconds = Math.ceil((config.worker.sensorDebounce - (Date.now() - lastTime)) / 1000);
|
|
console.log(`⏳ POT ${i}: Cooldown active (${remainingSeconds}s remaining)`);
|
|
continue;
|
|
}
|
|
|
|
console.log(`\n🌡️ SENSOR TRIGGERED: POT ${i}`);
|
|
console.log(` Soil moisture: ${soilValue}% < ${batasBawah}%`);
|
|
console.log(` Mode: ${modeSensor}, Duration: ${durasiSensor}s`);
|
|
|
|
const jobId = `sensor-pot-${i}-${Date.now()}`;
|
|
await wateringQueue.add(
|
|
`sensor-pot-${i}`,
|
|
{
|
|
type: 'sensor_threshold',
|
|
potNumbers: [i],
|
|
pompaAir: true,
|
|
pompaPupuk: false, // No pupuk for sensor mode
|
|
duration: durasiSensor,
|
|
scheduleId: jobId,
|
|
sensorData: { soilValue, batasBawah, batasAtas, mode: modeSensor },
|
|
},
|
|
{
|
|
jobId,
|
|
removeOnComplete: true,
|
|
priority: 1, // Higher priority for sensor-triggered
|
|
}
|
|
);
|
|
|
|
console.log(` 📌 Added to queue: ${jobId}`);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error('❌ Error in sensor monitoring:', error.message);
|
|
}
|
|
});
|
|
}
|
|
|
|
setupSensorMonitoring();
|
|
|
|
// ==================== HISTORY LOGGING ====================
|
|
|
|
async function logHistory(type, potNumbers, duration) {
|
|
try {
|
|
const now = new Date();
|
|
const dateKey = `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, '0')}-${now.getDate().toString().padStart(2, '0')}`;
|
|
const timeKey = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
|
|
|
|
// Get current sensor data
|
|
const sensorSnapshot = await db.ref('data').once('value');
|
|
const sensorData = sensorSnapshot.val() || {};
|
|
|
|
await db.ref(`history/${dateKey}/${timeKey}`).set({
|
|
timestamp: now.getTime(),
|
|
type: type,
|
|
pots: potNumbers,
|
|
duration: duration,
|
|
...sensorData,
|
|
});
|
|
|
|
console.log(` 📊 History logged: ${dateKey} ${timeKey}`);
|
|
} catch (error) {
|
|
console.error(' ⚠️ Failed to log history:', error.message);
|
|
}
|
|
}
|
|
|
|
// ==================== PERIODIC HISTORY LOGGING ====================
|
|
|
|
// Auto-log sensor data setiap 10 menit (independent from watering)
|
|
const autoLogJob = new cron.CronJob('*/10 * * * *', async () => {
|
|
try {
|
|
const sensorSnapshot = await db.ref('data').once('value');
|
|
const sensorData = sensorSnapshot.val();
|
|
|
|
if (sensorData) {
|
|
const now = new Date();
|
|
const dateKey = `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, '0')}-${now.getDate().toString().padStart(2, '0')}`;
|
|
const timeKey = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
|
|
|
|
await db.ref(`history/${dateKey}/${timeKey}`).set({
|
|
timestamp: now.getTime(),
|
|
type: 'auto_log',
|
|
...sensorData,
|
|
});
|
|
|
|
console.log(`📊 Auto-logged sensor data: ${timeKey}`);
|
|
}
|
|
} catch (error) {
|
|
console.error('❌ Auto-log failed:', error.message);
|
|
}
|
|
});
|
|
|
|
autoLogJob.start();
|
|
console.log('✅ Auto history logging started (every 10 minutes)');
|
|
|
|
// ==================== CLEANUP OLD HISTORY (DAILY) ====================
|
|
|
|
const cleanupJob = new cron.CronJob('0 2 * * *', async () => {
|
|
// Run daily at 2 AM
|
|
try {
|
|
console.log('\n🧹 Running history cleanup...');
|
|
const daysToKeep = 30;
|
|
const cutoffDate = new Date();
|
|
cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
|
|
|
|
const historySnapshot = await db.ref('history').once('value');
|
|
const historyData = historySnapshot.val();
|
|
|
|
if (historyData) {
|
|
let deletedCount = 0;
|
|
for (const dateKey in historyData) {
|
|
try {
|
|
const [year, month, day] = dateKey.split('-').map(Number);
|
|
const date = new Date(year, month - 1, day);
|
|
|
|
if (date < cutoffDate) {
|
|
await db.ref(`history/${dateKey}`).remove();
|
|
deletedCount++;
|
|
console.log(` 🗑️ Deleted: ${dateKey}`);
|
|
}
|
|
} catch (error) {
|
|
console.error(` ⚠️ Error deleting ${dateKey}:`, error.message);
|
|
}
|
|
}
|
|
console.log(`✅ Cleanup completed: ${deletedCount} dates removed`);
|
|
}
|
|
} catch (error) {
|
|
console.error('❌ Cleanup failed:', error.message);
|
|
}
|
|
});
|
|
|
|
cleanupJob.start();
|
|
console.log('✅ History cleanup scheduled (daily at 2 AM)');
|
|
|
|
// ==================== UTILITIES ====================
|
|
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
// ==================== HEALTH CHECK ====================
|
|
|
|
async function healthCheck() {
|
|
try {
|
|
// Check Firebase connection
|
|
await db.ref('.info/connected').once('value');
|
|
|
|
// Check Redis connection
|
|
await redis.ping();
|
|
|
|
// Check queue
|
|
const queueStatus = await wateringQueue.getJobCounts();
|
|
|
|
console.log('\n💚 HEALTH CHECK:');
|
|
console.log(` Firebase: ✅ Connected`);
|
|
console.log(` Redis: ✅ Connected`);
|
|
console.log(` Queue: ${queueStatus.active} active, ${queueStatus.waiting} waiting`);
|
|
} catch (error) {
|
|
console.error('❤️🩹 HEALTH CHECK FAILED:', error.message);
|
|
}
|
|
}
|
|
|
|
// Run health check every 5 minutes
|
|
setInterval(healthCheck, 300000);
|
|
|
|
// ==================== GRACEFUL SHUTDOWN ====================
|
|
|
|
async function shutdown() {
|
|
console.log('\n🛑 Shutting down gracefully...');
|
|
|
|
try {
|
|
await wateringWorker.close();
|
|
console.log('✅ Worker closed');
|
|
|
|
await wateringQueue.close();
|
|
console.log('✅ Queue closed');
|
|
|
|
await redis.quit();
|
|
console.log('✅ Redis disconnected');
|
|
|
|
await admin.app().delete();
|
|
console.log('✅ Firebase disconnected');
|
|
|
|
process.exit(0);
|
|
} catch (error) {
|
|
console.error('❌ Shutdown error:', error.message);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
process.on('SIGTERM', shutdown);
|
|
process.on('SIGINT', shutdown);
|
|
|
|
// ==================== STARTUP COMPLETE ====================
|
|
|
|
console.log('\n✨ ApsGo Railway Worker is running!');
|
|
console.log('📊 Features enabled:');
|
|
console.log(' • Waktu Mode (Time-based scheduling)');
|
|
console.log(' • Sensor Mode (Threshold-based automation)');
|
|
console.log(' • Auto History Logging (every 10 min)');
|
|
console.log(' • History Cleanup (daily at 2 AM)');
|
|
console.log(' • Health Check (every 5 min)');
|
|
console.log('\n🎯 Worker is ready to process jobs...\n');
|
|
|
|
// Initial health check
|
|
setTimeout(healthCheck, 5000);
|