phploy

#! /usr/bin/env php
<?php
/**
 * PHPloy - A PHP Deployment Script
 *
 * @package PHPloy
 * @author Baki Goxhaj <banago@gmail.com>
 * @author Fadion Dashi <jonidashi@gmail.com>
 * @author Bruno De Barros <bruno@terraduo.com>
 * @link http://wplancer.com
 * @licence MIT Licence
 * @version 2.0.0-beta
 */

/**
 * Run deployment
 */
try {
    $phploy = new PHPloy();
} catch (Exception $e) {
    // Display the error in red
    echo "\r\n\033[31mOh Snap: {$e->getMessage()}\033[0m\r\n\r\n";
}

/**
 * PHPloy Class
 */
class PHPloy
{

    /**
     * @var string $revision
     */
    public $revision;

    /**
     * A list of files that should NOT be uploaded to the remote server
     * (must match the absolute path in its entirety)
     *
     * @todo - implement the ability to specify entire folders (or use wildcards?) here
     * @var array $filesToIgnore
     */
    public $filesToIgnore = array(
        '.gitignore',
        '.gitmodules',
    );

    /**
     * If you need support for sub-submodules, ensure this is set to TRUE
     * Set to false when the --skip-subsubmodules command line option is used
     * 
     * @var bool $scanForSubSubmodules
     */
    public $scanForSubSubmodules = true;

    /**
     * @var array $servers
     */
    public $servers = array();

    /**
     * @var array $submodules
     */
    public $submodules = array();

    /**
     * The name of the file on remote servers that stores the current revision hash
     * 
     * @var string $dotRevisionFilename
     */
    public $dotRevisionFilename = '.revision';

    /**
     * The filename from which to read remote server details
     * 
     * @var string $deplyIniFilename
     */
    public $deployIniFilename = 'deploy.ini';

    /**
     * @var string $phployVersion
     */
    protected $phployVersion = '2.0.0-beta';

    /**
     * List of available "short" command line options, prefixed by a single hyphen
     * Colon suffix indicates that the option requires a value
     * Double-colon suffix indicates that the option *may* accept a value
     * See descriptions below
     *
     * @var string $shortops
     */
    protected $shortopts  = 'ls:';

    /**
     * List of available "long" command line options, prefixed by double-hyphen
     * Colon suffix indicates that the option requires a value
     * Double-colon suffix indicates that the option *may* accept a value
     * 
     *      --list or -l                      Lists the files that *would* be deployed if run without this option
     *      --rollback                        Deploys the previous commit/revision
     *      --rollback="[revision hash]"      Deploys the specific commit/revision
     *      --server="[server name]"          Deploys to the server entry listed in deploy.ini
     *        or -s [server name]
     *      --sync                            Updates the remote .revision file with the hash of the current HEAD
     *      --sync="[revision hash]"          Updates the remove .revision file with the provided hash
     *      --skip-subsubmodules              Skips the scanning of sub-submodules which is currently quite slow
     * 
     * @var array $longopts
     */
    protected $longopts  = array('list', 'rollback::', 'server:', 'sync::', 'skip-subsubmodules');

    /**
     * @var bool|resource $connection
     */
    protected $connection = false;

    /**
     * @var string $server
     */
    protected $server = '';

    /**
     * @var string $repo
     */
    protected $repo;

    /**
     * @var string $mainRepo
     */
    protected $mainRepo;

    /**
     * @var bool|string $currentSubmoduleName
     */
    protected $currentSubmoduleName = false;

    /**
     * Holds the path to the .revision file
     * For the main repository this will be the value of $dotRevisionFilename ('.revision' by default)
     * but for submodules, the submodule path will be prepended
     * 
     * @var string $dotRevision
     */
    protected $dotRevision;

    /**
     * @var bool $listFiles
     */
    protected $listFiles = false;

    /**
     * @var bool $sync
     */
    protected $sync = false;


    /**
     * Constructor
     */
    public function __construct()
    {
        $this->parseOptions();

        $this->output("\r\n-------------- phploy v{$this->phployVersion} ----------------\r\n");

        if (file_exists("$this->repo/.git")) {
            $this->output('Scanning repository...');
            $this->checkSubmodules($this->repo);
            $this->deploy($this->revision);
        } else {
            throw new Exception("'{$this->repo}' is not Git repository.");
        }
    }

    /**
     * Parse CLI options
     * For descriptions of the various options, see the comments for $this->longopts
     */
    protected function parseOptions()
    {
        $options = getopt($this->shortopts, $this->longopts);

        if (isset($options['l']) or isset($options['list'])) {
            $this->listFiles = true;
        }

        if (isset($options['s']) or isset($options['server'])) {
            $this->server = isset($options['s']) ? $options['s'] : $options['server'];
        }

        if (isset($options['sync'])) {
            $this->sync = empty($options['sync']) ? 'sync' : $options['sync'];
        }

        if (isset($options['rollback'])) {
            $this->revision = ($options['rollback'] == '') ? 'HEAD^' : $options['rollback'];
        } else {
            $this->revision = 'HEAD';
        }

        if (isset($options['skip-subsubmodules'])) {
            $this->scanForSubSubmodules = false;
        }

        $this->repo = isset($opts['repo']) ? rtrim($opts['repo'], '/') : getcwd();
        $this->mainRepo = $this->repo;
    }

    /**
     * Check for submodules
     * 
     * @param string $repo
     */
    protected function checkSubmodules($repo)
    {
        $command = "git --git-dir=\"$repo/.git\" --work-tree=\"$repo\" submodule status";
        $output = array();

        exec(escapeshellcmd($command), $output);

        $this->output('   Found '.count($output).' submodules.');
        if (count($output) > 0) {
            foreach ($output as $line) {
                $line = explode(' ', trim($line));
                $this->submodules[] = array('revision' => $line[0], 'name' => $line[1], 'path' => $repo.'/'.$line[1]);
                $this->filesToIgnore[] = $line[1];
                $this->output(sprintf('   Found submodule %s. %s', 
                    $line[1],
                    $this->scanForSubSubmodules ? 'Scanning for sub-submodules...' : null
                ));
                // The call to checkSubSubmodules also calls a git foreach
                // So perhaps it should be *outside* the loop here?
                if ($this->scanForSubSubmodules)
                    $this->checkSubSubmodules($repo, $line[1]);
            }
            if (!$this->scanForSubSubmodules)
                $this->output('   Skipping search for sub-submodules.');
        }
    }

    /**
     * Check for sub-submodules
     *
     * @todo This function is quite slow (at least on Windows it often takes several seconds for each call).
     *       Can it be optimized?
     *       It appears that this is called for EACH submodule, but then also does another `git submodule foreach`
     * @param string $repo
     * @param string $name
     */
    protected function checkSubSubmodules($repo, $name)
    {
        $command = "git --git-dir=\"$repo/.git\" --work-tree=\"$repo\" submodule foreach git submodule status";
        $output = array();

        exec(escapeshellcmd($command), $output);

        if (count($output) > 0) {
            foreach ($output as $line) {
                $line = explode(' ', trim($line));

                if (trim($line[0]) == 'Entering') continue;
                
                $this->submodules[] = array('revision' => $line[0], 'name' => $name.'/'.$line[1], 'path' => $repo.'/'.$name.'/'.$line[1]);
                $this->filesToIgnore[] = $line[1];
                $this->output(sprintf('      Found sub-submodule %s.', "$name/$line[1]"));
            }
        }
    }

    /**
     * Parse Credentials
     * 
     * @param string $deploy
     */
    protected function parseCredentials($deploy)
    {
        if (! file_exists($deploy)) {
            throw new Exception("'$deploy' does not exist.");
        } else {
            $servers = parse_ini_file($deploy, true);

            if (! $servers) {
                 throw new Exception("'$deploy' is not a valid .ini file.");
            } else {
                $this->filesToIgnore[] = $deploy;
                return $servers;
            }
        }
    }

    /**
     * Reads the deploy.ini file and populates the $this->servers array
     */
    protected function prepareServers()
    {
        $defaults = array(
            'host' => '',
            'user' => '',
            'pass' => '',
            'port' => 21,
            'path' => '/',
            'passive' => true,
            'clean_directories' => array()
        );
        
        $servers = $this->parseCredentials($this->deployIniFilename);

        foreach ($servers as $name => $options) {
            if ($name == 'quickmode') {
                foreach ($options as $env => $creds) {
                    $options = parse_url($creds);
                    $options = array_merge($defaults, $options);
                    $this->servers[$env] = $options;
                }
                break;
            }

            $options = array_merge($defaults, $options);

            $this->servers[$name] = $options;
        }
    }

    /**
     * Compare revisions and return files to upload
     *
     * @param string $localRevision
     * @return array
     * @throws Exception if unknown git diff status
     */
    protected function compare($localRevision)
    {
        $remoteRevision = null;
        $tmpFile = tmpfile();
        $filesToUpload = array();
        $filesToDelete = array();
        $output = array();

        if ($this->currentSubmoduleName) {
            $this->dotRevision = $this->currentSubmoduleName.'/'.$this->dotRevisionFilename;
        } else {
            $this->dotRevision = $this->dotRevisionFilename;
        }

        // Fetch the .revision file from the server and write it to $tmpFile
        if (@ftp_fget($this->connection, $tmpFile, $this->dotRevision, FTP_ASCII)) {
            fseek($tmpFile, 0);
            $remoteRevision = trim(fread($tmpFile, 1024));
        } else {
            $this->output('No remote revision file present. Running a fresh deployment - grab a coffee...');
        }
        fclose($tmpFile);

        // Use git to list the changed files between $remoteRevision and $localRevision
        $gitCommand = 'git --git-dir="'.$this->repo.'/.git" --work-tree="'.$this->repo.'"';

        if (empty($remoteRevision)) {
            $command = $gitCommand.' ls-files';
        } else if ($localRevision == 'HEAD') {
            $command = $gitCommand.' diff --name-status '.$remoteRevision.'...'.$localRevision;
        } else {
            $command = $gitCommand.' diff --name-status '.$remoteRevision.'... '.$localRevision;
        }

        exec(escapeshellcmd($command), $output);

		if (! empty($remoteRevision)) {
	        foreach ($output as $line) {
	            if ($line[0] == 'A' or $line[0] == 'C' or $line[0] == 'M') {
	                // Added (A), Modified (C), Unmerged (M)
	                $filesToUpload[] = trim(substr($line, 1));
	            } elseif ($line[0] == 'D') {
	                // Deleted (D)
	                $filesToDelete[] = trim(substr($line, 1));
	            } else {
	                throw new Exception("Unknown git-diff status: {$line[0]}");
	            }
	        }
        } else {
		    $filesToUpload = $output;
		}

        $filesToUpload = array_diff($filesToUpload, $this->filesToIgnore);

        return array(
            'upload' => $filesToUpload,
            'delete' => $filesToDelete
        );
    }

    /**
     * Deploy (or list) changed files
     * 
     * @param string $revision
     */
    public function deploy($revision = 'HEAD') 
    {
        $this->prepareServers();

        // Exit with an error if the specified server does not exist in deploy.ini
        if ($this->server != '' && !array_key_exists($this->server, $this->servers))
            throw new Exception("The server \"{$this->server}\" is not defined in {$this->deployIniFilename}.");

        // Loop through all the servers in deploy.ini
        foreach ($this->servers as $name => $server) {
            
            // Deploys to ALL servers by default
            // If a server is specified, we skip all servers that don't match the one specified
            if ($this->server != '' && $this->server != $name) continue;

            $this->output("\r\nConnecting to $name server ($server[host])...");
            $this->connect($server);

            if( $this->sync ) {
                $this->dotRevision = $this->dotRevisionFilename;
                // We update .revision file, but don't do any listing or deploying
                $this->setRevision();
                ftp_close($this->connection);
                continue;
            }
            
            $files = $this->compare($revision);

            $this->output("\r\nSERVER: ".$name);
            if ($this->listFiles === true) {
                $this->listFiles($files);
            } else {
                $this->push($files);
            }

            if (count($this->submodules) > 0) {
                foreach ($this->submodules as $submodule) {
                    $this->repo = $submodule['path'];
                    $this->currentSubmoduleName = $submodule['name'];
                    
                    $this->output("\r\nSUBMODULE: ".$this->currentSubmoduleName);
                    
                    $files = $this->compare($revision);

                    if ($this->listFiles === true) {
                        $this->listFiles($files);
                    } else {
                        $this->push($files);
                    } 
                }
                // We've finished deploying submodules, reset settings for the next server
                $this->repo = $this->mainRepo;
                $this->currentSubmoduleName = false;
            }
            if (!$this->listFiles) {
                $this->output("\r\n------ Deployment complete ------");
            }

            ftp_close($this->connection);
        }         
    }

    /**
     * Check what files will be uploaded/deleted
     * 
     * @param array $files
     */
    protected function listFiles($files)
    {
        if (count($files['upload']) == 0 && count($files['delete']) == 0) {
            $this->output("   No files to upload.");
        }

        if (count($files['upload']) > 0) {
            $this->output("Files to upload:");

            foreach ($files['upload'] as $file_to_upload) {
                $this->output(" Upload: ".$file_to_upload);
            }
        }

        if (count($files['delete']) > 0) {
            $this->output("Files to delete:");

            foreach ($files['delete'] as $file_to_delete) {
                $this->output(" Delete: ".$file_to_delete);
            }
        }
    }

    /**
     * Connect to the Server
     * 
     * @param string $server
     * @throws Exception if it can't connect to FTP server
     * @throws Exception if it can't login to FTP server
     * @throws Exception if it can't change FTP directory
     */
    protected function connect($server)
    {
        // Make sure the $path ends with a slash.
        $server['path'] = rtrim($server['path'], '/').'/';

        $pathsThatExist = array();

        $connection = @ftp_connect($server['host'], $server['port']);

        if ($connection) {
            if (! ftp_login($connection, $server['user'], $server['pass'])) {
                throw new Exception("Could not login to {$server['host']} (Tried to login as {$server['user']}).");
            }

            ftp_pasv($connection, $server['passive']);

            if (@ftp_chdir($connection, $server['path'])) {
                $this->connection = $connection;
                $this->output("Connected.");
            } else {
                throw new Exception("Could not change the FTP directory to {$server['path']}.");
            }
        } else {
            throw new Exception("Could not connect to {$server['host']}.");
        }
    }

    /**
     * Push Files one by one.
     */
    protected function push($files)
    {
        // If revision is not HEAD, the current one, it means this is a rollback.
        // So, we have to revert the files the the state they were in that revision.
        if ($this->revision != 'HEAD') {
            $this->output("Rolling back");
            $command = 'git --git-dir="'.$this->repo.'/.git" --work-tree="'.$this->repo.'" checkout '.$this->revision;
            exec(escapeshellcmd($command));
        }

        $filesToUpload = $files['upload'];
        $filesToDelete = $files['delete'];
        unset($files);

        foreach ($filesToUpload as $file) {
            if ($this->currentSubmoduleName) $file = $this->currentSubmoduleName.'/'.$file;

            // Make sure the folder exists in the FTP server.
            $dir = explode("/", dirname($file));
            $path = "";
            $ret = true;

            for($i = 0, $count = count($dir); $i < $count; $i++) {
                $path .= $dir[$i].'/';

                if (! isset($pathsThatExist[$path])) {
                    $origin = ftp_pwd($this->connection);
                    
                    if (! @ftp_chdir($this->connection, $path)) {
                        if (! ftp_mkdir($this->connection, $path)) {
                            $ret = false;
                            
                            $this->output("   Failed to create '$path'.");
                            $this->output("   Directory could not be created. Please check if a file with the same name exists in the server and delete it.");
                            
                            return;
                        } else {
                            $this->output("   Created directory '$path'.");
                            $pathsThatExist[$path] = true;
                        }
                    } else {
                        $pathsThatExist[$path] = true;
                    }
                
                    @ftp_chdir($this->connection, $origin);
                }
            }

            $uploaded = false;
            $attempts = 1;
            
            while (! $uploaded) {
                if ($attempts == 10) {
                    throw new Exception("Tried to upload $file 10 times and failed. Something is wrong...");
                }

                $uploaded = ftp_put($this->connection, $file, $file, FTP_BINARY);

                if (! $uploaded) {
                    $attempts = $attempts + 1;
                    $this->output("   Failed to upload {$file}. Retrying (attempt $attempts/10)... ");
                }
            }
            
            $this->output("   \033[0;32muploaded\033[0m \033[01;37m{$file}\033[0m");
        }

        foreach ($filesToDelete as $file) {
            ftp_delete($this->connection, $file);
            $this->output("   \033[01;31mremoved\033[0m \033[01;37m{$file}\033[0m ");
        }

        if (! empty($server['clean_directories'])) {
            foreach ($server['clean_directories'] as $dir) {
                if (! $tmpFiles = ftp_nlist($this->connection, $dir)) {
                    $this->output("{$dir} already empty");
                    continue;
                }

                foreach ($tmpFiles as $file) {
                    ftp_delete($this->connection, $file);
                }

                $this->output("   \033[01;31memptied\033[0m \033[01;37m{$dir}\033[0m");
            }
        }

        if (count($filesToUpload) > 0 or count($filesToDelete) > 0) {            
            // Set revision on server
            $this->setRevision();              
        } else {
            $this->output("   No files to upload.");
        }

        // If revision is not HEAD, the current one, it means this is a rollback.
        // So, we have to revert the master because we reverted to an earlier
        // revision before the deploy start.
        if ($this->revision != 'HEAD') {
            $command = 'git --git-dir="'.$this->repo.'/.git" --work-tree="'.$this->repo.'" checkout master';
            exec(escapeshellcmd($command));
        }
    }

    /**
     * Sets version hash on the server.
     */
    protected function setRevision()
    {
        // By default we update the revision file to the HEAD commit, 
        // unless the sync command was called with a specific revision
        $isHeadRevision = $this->sync == 'sync' || $this->sync == false;
        if ( $isHeadRevision ) {
            // Find the revision number of HEAD
            $command = "git --git-dir=\"$this->repo/.git\" --work-tree=\"$this->repo\" rev-parse HEAD";
            exec(escapeshellcmd($command), $localRevision);
        } else {
            $localRevision = $this->sync;
        }
        
        $temp = tempnam(sys_get_temp_dir(), 'gitRevision');
        file_put_contents($temp, $localRevision);

        if ( $this->sync ) {
            $this->output("\r\nSYNC: Updating remote revision file to ".
                ($isHeadRevision ? 'current HEAD ('.$localRevision.')' : $localRevision)
            );
        }

        if (ftp_put($this->connection, $this->dotRevision, $temp, FTP_BINARY)) {         
            unlink($temp);
            $this->output("   Remote revision file updated.");
        } else {
            throw new Exception("Could not update the revision file on server.");   
        }                
    }

    /**
     * Helper method to display messages on the screen.
     * 
     * @param string $message
     */
    public function output($message) {
        echo $message."\r\n";
    }

}