php python ftp operation class

php python ftp operation class

class Ftp {

 //FTP connection resource
 private $link;

 //FTP connection time
 public $link_time;

 //Error code
 private $err_code = 0;

 //Transfer mode {text mode: FTP_ASCII, binary mode: FTP_BINARY}
 public $mode = FTP_BINARY;

 /**
 Initialization class

 **/
 public function start($data)
 {
 if(empty($data ['port'])) $data['port'] ='21';
 if(empty($data['pasv'])) $data['pasv'] =false;
 if(empty($data ['ssl'])) $data['ssl'] = false;
 if(empty($data['timeout'])) $data['timeout'] = 30;
 return $this->connect( $data['server'],$data['username'],$data['password'],$data['port'],$data['pasv'],$data['ssl'],$data ['timeout']);
 }

 /**
 * Connect to FTP server
 * @param string $host Server address
 * @param string $username Username
 * @param string $password Password
 * @param integer $port Server port, the default value is 21
 * @param boolean $pasv Whether to enable passive mode
 * @param boolean $ssl　　 Whether to use SSL connection
 * @param integer $timeout Timeout time
*/
 public function connect($host, $username = '', $password = '', $port = '21', $pasv = false , $ssl = false, $timeout = 30) {
 $start = time();
 if ($ssl) {
 if (!$this->link = @ftp_ssl_connect($host, $port, $timeout) ) {
 $this->err_code = 1;
 return false;
 }
 } else {
 if (!$this->link = @ftp_connect($host, $port, $timeout)) {
 $this ->err_code = 1;
 return false;
 }
 }

 if (@ftp_login($this->link, $username, $password)) {
 if ($pasv)
 ftp_pasv($this-> ;link, true);
 $this->link_time = time() - $start;
 return true;
 } else {
 $this->err_code = 1;
 return false;
 }
 register_shutdown_function(array( &$this, 'close'));
 }

 /**
 * Create folder
 * @param string $dirname directory name,
*/
 public function mkdir($dirname) {
 if (!$this->link) {
 $this->err_code = 2;
 return false;
 }
 $dirname = $this->ck_dirname($dirname);
 $nowdir = '/';
 foreach ($dirname as $v) {
 if ($v && !$ this->chdir($nowdir . $v)) {
 if ($nowdir)
 $this->chdir($nowdir);
 @ftp_mkdir($this->link, $v);
 }
 if ($v)
 $nowdir .= $v . '/';
 }
 return true;
 }

 /**
 * Upload files
 * @param string $remote remote storage address
 * @param string $local local storage address
*/
 public function put($remote, $local) {
 if ( !$this->link) {
 $this->err_code = 2;
 return false;
 }
 $dirname = pathinfo($remote, PATHINFO_DIRNAME);
 if (!$this->chdir($dirname )) {
 $this->mkdir($dirname);
 }
 if (@ftp_put($this->link, $remote, $local, $this->mode)) {
 return true;
 } else {
 $this->err_code = 7;
 return false;
 }
 }

 /**
 * Delete folder
 * @param string $dirname directory address
 * @param boolean $enforce force deletion
*/
 public function rmdir($dirname, $enforce = false) {
 if (!$ this->link) {
 $this->err_code = 2;
 return false;
 }
 $list = $this->nlist($dirname);
 if ($list && $enforce) {
 $ this->chdir($dirname);
 foreach ($list as $v) {
 $this->f_delete($v);
 }
 } elseif ($list && !$enforce) {
 $this- >err_code = 3;
 return false;
 }
 @ftp_rmdir($this->link, $dirname);
 return true;
 }

    /**
 * Delete the specified file
 * @param string $filename file name
*/
    public function delete($filename) {
        if (!$this->link) {
            $this->err_code = 2;
            return false;
        }
        if (@ftp_delete($this->link, $filename)) {
            return true;
        } else {
            $this->err_code = 4;
            return false;
        }
    }

    /**
 * Return the file list of the given directory
 * @param string $dirname directory address
 * @return array file list data
*/
    public function nlist($dirname) {
        if (!$this->link) {
            $this->err_code = 2;
            return false;
        }
        if ($list = @ftp_nlist($this->link, $dirname)) {
            return $list;
        } else {
            $this->err_code = 5;
            return false;
        }
    }

    /**
 * Change the current directory on the FTP server
 * @param string $dirname Modify the current directory on the server
*/
    public function chdir($dirname) {
        if (!$this->link) {
            $this->err_code = 2;
            return false;
        }
        if (@ftp_chdir($this->link, $dirname)) {
            return true;
        } else {
            $this->err_code = 6;
            return false;
        }
    }

    /**
 * Get error message
*/
    public function get_error() {
        if (!$this->err_code)
            return false;
        $err_msg = array(
            '1' => 'Server can not connect',
            '2' => 'Not connect to server',
            '3' => 'Can not delete non-empty folder',
            '4' => 'Can not delete file',
            '5' => 'Can not get file list',
            '6' => 'Can not change the current directory on the server',
            '7' => 'Can not upload files'
        );
        return $err_msg[$this->err_code];
    }

    /**
 * Detect directory name
 * @param string $url directory
 * @return Return array separated by /
*/
    private function ck_dirname($url) {
        $url = str_replace('', '/', $url);
        $urls = explode('/', $url);
        return $urls;
    }

    /**
 * Close FTP connection
*/

    public function close() {
        return @ftp_close($this->link);
    }

}

#!/usr/bin/python
#coding=gbk
'''
 ftp automatic download, automatic upload script, recursive directory operation possible
'''

from ftplib import FTP
import os,sys, string, datetime, time
import socket

class MYFTP:
 def __init__(self, hostaddr, username, password, remotedir, port=21):
 self.hostaddr = hostaddr
 self.username = username
 self.password = password
 self.remotedir = remotedir
 self.port = port
 self.ftp = FTP()
 self.file_list = []
 # self.ftp.set_debuglevel(2)
 def __del__(self):
 self.ftp.close ()
 # self.ftp.set_debuglevel(0)
 def login(self):
 ftp = self.ftp
 try:
 timeout = 60
 socket.setdefaulttimeout(timeout)
 ftp.set_pasv(True)
 print 'Start Connect to %s' %(self.hostaddr)
 ftp.connect(self.hostaddr, self.port)
 print 'Successfully connected to %s' %(self.hostaddr)
 print 'Start logging in to %s' %( self.hostaddr)
 ftp.login(self.username, self.password)
 print 'Successfully logged in to %s' %(self.hostaddr)
 debug_print(ftp.getwelcome())
 except Exception:
 deal_error("Connect Or login failed")
 try:
 ftp.cwd(self.remotedir)
 except(Exception):
 deal_error('Failed to switch directories')

 def is_same_size(self, localfile, remotefile):
 try:
 remotefile_size = self.ftp.size(remotefile)
 except:
 remotefile_size = -1
 try:
 localfile_size = os.path.getsize(localfile)
 except:
 localfile_size = -1
 debug_print('lo:%d re:%d ' %(localfile_size, remotefile_size),)
 if remotefile_size == localfile_size:
 return 1
 else:
 return 0
 def download_file(self, localfile, remotefile):
 if self.is_same_size(localfile, remotefile):
 debug_print( '%s files are the same size, no need to download' %localfile)
 return
 else:
 debug_print('>>>>>>>>>>>>Download file %s ... ...' %localfile)
 #return
 file_handler = open(localfile, 'wb')
 self.ftp.retrbinary('RETR %s'%(remotefile), file_handler.write)
 file_handler.close( )

 def download_files(self, localdir='./', remotedir='./'):
 try:
 self.ftp.cwd(remotedir)
 except:
 debug_print('Directory %s does not exist, continue. ..' %remotedir)
 return
 if not os.path.isdir(localdir):
 os.makedirs(localdir)
 debug_print('Switch to directory %s' %self.ftp.pwd())
 self.file_list = []
 self.ftp.dir(self.get_file_list)
 remotenames = self.file_list
 #print(remotenames)
 #return
 for item in remotenames:
 filetype = item[0]
 filename = item[1]
 local = os.path.join(localdir, filename)
 if filetype == 'd':
 self.download_files(local, filename)
 elif filetype == '-':
 self.download_file(local, filename)
 self .ftp.cwd('..')
 debug_print('Return to upper directory %s' %self.ftp.pwd())
 def upload_file(self, localfile, remotefile):
 if not os.path.isfile(localfile ):
 return
 if self.is_same_size(localfile, remotefile):
 debug_print('Skip [equal]: %s' %localfile)
 return
 file_handler = open(localfile, 'rb')
 self.ftp.storbinary ('STOR %s' %remotefile, file_handler)
 file_handler.close()
 debug_print('Transmitted: %s' %localfile)
 def upload_files(self, localdir='./', remotedir = './') :
 if not os.path.isdir(localdir):
 return
 localnames = os.listdir(localdir)
 self.ftp.cwd(remotedir)
 for item in localnames:
 src = os.path.join(localdir, item)
 if os.path.isdir(src):
 try:
 self.ftp.mkd(item)
 except:
 debug_print('Directory already exists %s' %item)
 self.upload_files(src, item)
 else:
 self.upload_file(src, item)
 self.ftp.cwd('..')

 def get_file_list(self, line):
 ret_arr = []
 file_arr = self.get_filename(line)
 if file_arr[1] not in ['.', '..']:
 self.file_list.append(file_arr)

 def get_filename(self, line):
 pos = line.rfind(':')
 while( line[pos] != ' '):
 pos += 1
 while(line[pos] == ' '):
 pos += 1
 file_arr = [line[0], line[pos:]]
 return file_arr
def debug_print(s):
 print (s)
def deal_error(e):
 timenow = time.localtime()
 datenow = time.strftime('%Y-%m-%d', timenow)
 logstr = '%s An error occurred: %s' %(datenow, e)
 debug_print(logstr)
 file.write(logstr)
 sys.exit()

if __name__ == '__main__':
 file = open(" log.txt", "a")
 timenow = time.localtime()
 datenow = time.strftime('%Y-%m-%d', timenow)
 logstr = datenow
 # Configure the following variables
 hostaddr = ' localhost' # ftp address
 username = 'test' # Username
 password = 'test' # Password
 port = 21 # Port number
rootdir_local = '.' + os.sep + 'bak/' # Local directory
 rootdir_remote = './' # Remote directory

 f = MYFTP(hostaddr, username, password, rootdir_remote, port)
 f.login()
 f.download_files(rootdir_local, rootdir_remote)

 timenow = time.localtime()
 datenow = time.strftime('%Y-%m-%d', timenow)
 logstr += " - %s Successfully executed backup n " %datenow
 debug_print(logstr)

 file.write(logstr)
 file.close()