ECONNRESET Error using ftp after few mintues

[sudhir-pandey24]

I am using FTP Connection and download all files from folder.

I have written this script , its downloading few files but after few min getting this error.

Below my script:

     //create a connection to ftp server
     var downloadList = [];
     var allFileNames = [];

     const ftpConnection = async (callback) => {
 try{
	ftp_client.on('ready', function() { 
		ftp_client.list('/Gracenote',function(err, list) {
			list.map(function(entry){
				if (entry.name !== '.' && entry.name !== '..' && typeof entry.name !== 'undefined') {
					const pathArray = "data/" + entry.name;
					if (!fs.existsSync(pathArray)) {
						downloadList.push(entry.name);
					}
				}
			});	
			callback(downloadList);
			ftp_client.end();
		});
	});
	ftp_client.end();
      } catch (error) {
	       console.log(error);
      }
     }

       ftpConnection(function(a) {
           allFileNames = a;

         // Defining the queue
           const queue = asyncProccess.queue((task, completed) => {
                 console.log("Currently Busy Processing Task " + task);
                 // Simulating a Complex task
                  setTimeout(()=>{
	                    // The number of tasks to be processed
	                   const remaining = queue.length();
	                   completed(null, {task, remaining});
	                  downloadXMLFile(task);
                    }, 3000);
                   }, 1); // The concurrency value is 1

            // Adding the each task to the queue
           allFileNames.forEach((task)=>{
	     queue.push(task, (error, {task, remaining})=>{
		if(error){
		 console.log(`An error occurred while processing task ${task}`);
		}else {
		 console.log(`Finished processing task ${task}. ${remaining} tasks remaining`);
	       }
	   }); 
	
         });
	// Executes the callback when the queue is done processing all the tasks
         queue.drain(() => {
	          console.log('Successfully processed all items');
            });

       });

       ftp_client.connect(ftpConfig);

       const downloadXMLFile = async function (fileName) {
    try{
	const path = "data/" + fileName;
	if (!fs.existsSync(path)) {
		let d = new FTPClient();
		d.on('ready', function() {
			if (fileName !== '.' && fileName !== '..' && typeof fileName !== 'undefined') {
				d.get(`Gracenote/${fileName}`, function(err, stream) {
				if (err) console.dir(err);
				if(!err){
						console.log(`copied file Gracenote/${fileName}`);
						stream.once('close', function() { d.end(); });
						stream.pipe(fs.createWriteStream('data/'+ fileName,{flags: 'w'}));
				}
				});
			}
		});
		d.end();
		d.connect(ftpConfig);
	}	
        }catch (err) {
	          return err.message;
        }
        };

[iserioton]

Having the same issue.
I have a cron job that runs after every five minutes. I am using a non-persistence connection so on every hit there will be a new connection.

`class FTP {
constructor() {
this.ftpLiveClient = new ftp();
this.connection_closed = false;
}

create_session() {
return new Promise(async (resolve) => {
try {
this.ftpLiveClient.connect(creds);

    await Promise.allSettled([
      new Promise((res) => {
        this.ftpLiveClient.on("ready", () => {
          res();
        });
      }),
    ]);

    this.uuid = uuidv4();
    save_session(this.uuid); // Save session open date time in log file

    this.watch_error();
    resolve(true);
  } catch (error) {
    close_connection();
    resolve(false);
  }
});

}

watch_error() {
this.ftpLiveClient.on(
"error",
function (err) {
this.close_connection();
}.bind(this)
);
}

close_connection() {
this.connection_closed = true;
this.ftpLiveClient.end();
close_session(this.uuid); // Update session close date time in log file
}
}

// Get file names from server.
function get_file_names(dir_path) {
return new Promise(async (resolve) => {
try {
let ftp_obj = new FTP();
await ftp_obj.create_session();
ftp_obj.ftpLiveClient.list(dir_path, function (err, list) {
ftp_obj.close_connection();
if (err) {
return resolve(false);
}
return resolve(list);
});
} catch (e) {
return resolve(false);
}
});
}

// Read file content from server.
function read_file(file_path) {
return new Promise(async (resolve) => {
try {
let ftp_obj = new FTP();
await ftp_obj.create_session();
ftp_obj.ftpLiveClient.get(file_path, function (err, stream) {
if (err) {
ftp_obj.close_connection();
return resolve(false);
}
let tempBuffer = [];
stream.on("data", (chunk) => {
tempBuffer.push(chunk);
});
stream.on("end", () => {
tempBuffer = Buffer.concat(tempBuffer).toString();
ftp_obj.close_connection();
return resolve(tempBuffer);
});
stream.on("error", (err) => {
ftp_obj.close_connection();
return resolve(false);
});
});
} catch (e) {
return resolve(false);
}
});
}`

I used file data directly, I am not saving the file in the system.

let file_names = await get_file_names(dir_path); let len = file_names.length; while (len--) { let file_name = file_names[len]; let file_path = dir_path + file_name; let data = await read_file(file_path); }