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); }