119 lines
4.3 KiB
TypeScript
119 lines
4.3 KiB
TypeScript
import {QueueManager} from './queue_manager';
|
|
import {TcpCommunicator} from "./tcp_communicator"; // Updated to use TcpCommunicator
|
|
import {operationCodes} from '../network/operation_codes';
|
|
import fs from "fs";
|
|
import path from "path";
|
|
import {compareFnFileItemTask, FileItemTask} from "../interfaces/file_item_task";
|
|
import {ParsedMessage} from "../network/message_handler";
|
|
|
|
interface FileSendTask {
|
|
ip: string;
|
|
path: string;
|
|
userName: string;
|
|
}
|
|
|
|
export class FileSharer {
|
|
private queueManager: QueueManager<FileSendTask>;
|
|
private readonly clientPort: number;
|
|
private isBusy: boolean;
|
|
private tcpCommunicator: TcpCommunicator | null = null;
|
|
|
|
constructor(queueFilePath: string, clientPort: number) {
|
|
this.queueManager = new QueueManager<FileItemTask>(queueFilePath, compareFnFileItemTask);
|
|
this.clientPort = clientPort;
|
|
this.isBusy = false; // Initialize the busy flag
|
|
}
|
|
|
|
// Start processing the file queue
|
|
async start(): Promise<void> {
|
|
setInterval(async () => {
|
|
if (!this.isBusy) { // Check if the queue is already being processed
|
|
await this.processQueue(); // Process the queue at regular intervals
|
|
}
|
|
}, 10000); // 10 seconds interval
|
|
}
|
|
|
|
// Method to process the queue
|
|
private async processQueue(): Promise<void> {
|
|
if (this.isBusy) {
|
|
console.log("Queue is already being processed. Skipping this interval.");
|
|
return;
|
|
}
|
|
|
|
this.isBusy = true; // Set busy flag to true before starting
|
|
|
|
while (!this.queueManager.isEmpty()) {
|
|
const task = this.queueManager.peek();
|
|
|
|
if (task) {
|
|
console.log(task);
|
|
const success = await this.sendFile(task);
|
|
|
|
if (!success) {
|
|
console.error(`Failed to send file: ${task.path} to IP: ${task.ip}. Re-adding to queue.`);
|
|
this.queueManager.dequeue();
|
|
this.queueManager.enqueue(task); // Re-add to queue if failed
|
|
} else {
|
|
console.log(`File sent successfully: ${task.path} to IP: ${task.ip}.`);
|
|
this.queueManager.dequeue();
|
|
}
|
|
}
|
|
}
|
|
this.isBusy = false; // Reset busy flag after the queue is processed
|
|
}
|
|
|
|
// Method to send the file to a specific IP using TcpCommunicator
|
|
private async sendFile(task: FileSendTask): Promise<boolean> {
|
|
const {ip, path: filePath, userName} = task;
|
|
|
|
// Ensure the file exists before attempting to send
|
|
if (!fs.existsSync(filePath)) {
|
|
console.error(`File not found: ${filePath}`);
|
|
return false;
|
|
}
|
|
|
|
// Read the file contents
|
|
const fileContent = fs.readFileSync(filePath);
|
|
|
|
// Extract the file name from the file path using path.basename
|
|
const fileName = path.basename(filePath);
|
|
|
|
const metaInfo = {
|
|
userName, // Sender's username
|
|
relativeFilePath: fileName, // Use the file name instead of the full path
|
|
};
|
|
|
|
this.tcpCommunicator = new TcpCommunicator(ip, this.clientPort);
|
|
|
|
if (!await this.tcpCommunicator.connect()) {
|
|
console.error(`Failed to connect to IP: ${ip}`);
|
|
return false;
|
|
}
|
|
|
|
console.log(`Sending file: ${filePath} to IP: ${ip}`);
|
|
|
|
if (!await this.tcpCommunicator.sendMessage(operationCodes.SHARE_FILE, metaInfo, fileContent)) return false;
|
|
|
|
const response = await this.waitForResponse();
|
|
if (!response || response.operationCode !== operationCodes.OK) {
|
|
console.error(`Failed to send file: ${filePath} to IP: ${ip}`);
|
|
return false;
|
|
}
|
|
|
|
await this.tcpCommunicator.disconnect();
|
|
return true;
|
|
}
|
|
|
|
private async waitForResponse(): Promise<ParsedMessage | null> {
|
|
return new Promise((resolve) => {
|
|
const idResponseCheck = setInterval(async () => {
|
|
if (!this.tcpCommunicator) return null;
|
|
if (this.tcpCommunicator.hasResponseArrived()) {
|
|
clearInterval(idResponseCheck);
|
|
resolve(this.tcpCommunicator.getLastResult()); // Resolve the response or null if not available
|
|
}
|
|
}, 100); // Check every 100 milliseconds if the response has arrived
|
|
});
|
|
}
|
|
}
|