git-deploy

#!/usr/bin/php
<?php
/*
 * @todo log all output in file
 * @todo command to set file
 * @todo command to set whether to print or not
 * @todo command to ignore arbitrary files
 * @todo command to update to specific revision (including previous, see issue #8)
 * @todo see if it ends in .ini, and if it does, don't append .ini
 */

$commands = array('-l', '-r', '--revert');

if (isset($argv[1])) {
    if (!in_array($argv[1], $commands)) {
        $deploy = $argv[1] . '.ini';
    } else {
        $deploy = 'deploy.ini';
    }
} else {
    $deploy = 'deploy.ini';
}

$opts = getopt("lr:", array("revert"));

$list = isset($opts['l']);
$revision = isset($opts['r']) ? $opts['r'] : 'HEAD';

$revert = isset($opts['revert']);

try {
    $git = new Terra_Git();
    if (!$list) {
        $git->setDeployFile($deploy);
        if ($revert) {
            $git->revert();
        } else {
            $git->deploy($revision);
        }
    } else {
        $files = $git->getFilesToUpload();
        if (count($files['upload']) > 0) {
            $git->output("Files to upload:");
            foreach ($files['upload'] as $fileToUpload) {
                $git->output($fileToUpload);
            }
        }

        if (count($files['delete']) > 0) {
            $git->output("Files to delete:");
            foreach ($files['delete'] as $fileToDelete) {
                $git->output($fileToDelete);
            }
        }
    }
} catch (Exception $e) {
    echo $e->getMessage();
}

class Terra_Git {

    protected $filesToIgnore = array(
        'git-deploy',
        '.gitignore',
    );
    protected $print = true;
    protected $logBuffer = '';
    protected $logFile = 'git-deploy.log.txt';
    protected $submodules = array();
    protected $servers = array();

    function __construct() {
        # Check if there are any submodules in the git repository.

        $command = "git submodule status";

        $output = array();
        exec($command, $output);

        foreach ($output as $line) {
            $line = explode(' ', $line);
            $this->submodules[] = $line[1];
        }
    }

    function setDeployFile($deploy) {
        if (!@file_exists($deploy)) {
            throw new Exception("File '$deploy' does not exist.");
        } else {
            $servers = parse_ini_file($deploy, true);
            if (!$servers) {
                throw new Exception("File '$deploy' is not a valid .ini file.");
            } else {
                $this->addServers($servers);
            }
        }
        $this->ignoreFile($deploy);
    }

    function addServers($servers) {
        foreach ($servers as $uri => $options) {

            if (substr($uri, 0, 6) === 'ftp://') {
                $options = array_merge($options, parse_url($uri));
            }

            # Throw in some default values, in case they're not set.
            $options = array_merge(array(
                'skip' => false,
                'host' => '',
                'user' => '',
                'pass' => '',
                'port' => 21,
                'path' => '/',
                'passive' => true,
                'clean_directories' => array()
                    ), $options);

            if ($options['skip']) {
                continue;
            } else {
                $this->servers[$uri] = $options;
            }
        }
    }

    function ignoreFile($file) {
        $this->filesToIgnore[] = $file;
    }

    function getFilesToUpload($oldRevision = null, $newRevision = 'HEAD') {
        # Get the list of files to update.

        if (!empty($oldRevision)) {
            $command = "git diff --name-status {$oldRevision} {$newRevision}";
        } else {
            $command = "git ls-files";
        }

        $output = array();
        exec($command, $output);

        $filesToUpload = array();
        $filesToDelete = array();

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

        foreach ($filesToUpload as $key => $file) {
            if (in_array($file, $this->filesToIgnore)) {
                unset($filesToUpload[$key]);
            }
        }

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

    function output($message) {
        if ($this->print) {
            echo $message . "\r\n";
        } else {
            $this->logBuffer .= $message . "\r\n";
        }
    }

    function __destruct() {
        
    }

    function revert() {
        foreach ($this->servers as $server) {
            $this->deployGitOverFtp($server, 'HEAD', true);
        }
    }

    function deploy($revision = 'HEAD') {
        foreach ($this->servers as $server) {
            $this->deployGitOverFtp($server, $revision);
        }
    }

    function deployGitOverFtp($server, $revision = 'HEAD', $revert = false) {

        if ($revision == 'HEAD') {
            $revision = exec('git rev-parse HEAD');
        }

        # Let's make sure the $path ends with a slash.

        if (substr($server['path'], strlen($server['path']) - 1, strlen($server['path'])) !== '/') {
            $server['path'] = $server['path'] . '/';
        }

        $pathsThatExist = array();

        # Okay, let's connect to the server.

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

        if (!$connection) {
            throw new Exception("Could not connect to {$server['host']}.");
        } else {

            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'])) {
                
            } else {
                throw new Exception("Could not change the FTP directory to {$server['path']}.");
            }

            $this->output(("----------------------------"));
            $this->output("Connected to {$server['host']}{$server['path']}");
            $this->output("----------------------------");

            # Now that we're logged in to the server, let's get the remote revision.

            $remoteRevision = '';

            $tmpFile = tmpfile();

            if (@ftp_fget($connection, $tmpFile, 'REVISION', FTP_ASCII)) {
                fseek($tmpFile, 0);
                $remoteRevision = trim(fread($tmpFile, 1024));
                fclose($tmpFile);
            } else {
                # Couldn't get the file. I assume it's because the file didn't exist.
            }

            $tmpFile = tmpfile();

            if (@ftp_fget($connection, $tmpFile, 'PREVIOUS_REVISION', FTP_ASCII)) {
                fseek($tmpFile, 0);
                $previousRevision = trim(fread($tmpFile, 1024));
                fclose($tmpFile);
            } else {
                # Couldn't get the file. I assume it's because the file didn't exist.
            }

            if ($revert) {

                if (!isset($previousRevision)) {
                    throw new Exception("Could not find previous revision in {$server['host']}, which means that reverting is not possible.");
                }

                # Set revision to PREVIOUS_REVISION, for reverting.
                $revision = $previousRevision;
                if ($remoteRevision != $revision) {
                    $this->output("Reverting from " . substr($remoteRevision, 0, 6) . " to " . substr($revision, 0, 6) . ".");
                    $this->output("----------------------------");
                }
            } else {
                if ($remoteRevision != $revision) {
                    $this->output("Deploying update from " . substr($remoteRevision, 0, 6) . " to " . substr($revision, 0, 6) . ".");
                    $this->output("----------------------------");
                }
            }

            $files = $this->getFilesToUpload($remoteRevision, $revision);
            $filesToUpload = $files['upload'];
            $filesToDelete = $files['delete'];
            unset($files);

            foreach ($filesToUpload as $file) {
                # Make sure the folder exists in the FTP server.

                $dir = explode("/", dirname($file));
                $path = "";
                $ret = true;

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

                    if (!isset($pathsThatExist[$path])) {
                        $origin = ftp_pwd($connection);

                        if (!@ftp_chdir($connection, $path)) {
                            if (!@ftp_mkdir($connection, $path)) {
                                $ret = false;
                                $this->output("Failed to create '$path'.");
                                $this->output("A problem occurred while attempting to create a folder. Upload to this server cannot continue.");
                                return;
                            } else {
                                $this->output("Created directory '$path'.");
                                $pathsThatExist[$path] = true;
                            }
                        } else {
                            $pathsThatExist[$path] = true;
                        }

                        ftp_chdir($connection, $origin);
                    }
                }

                $uploaded = false;
                $attempts = 1;
                while (!$uploaded) {

                    if ($attempts == 10) {
                        $this->output("Tried to upload $file 10 times, and failed 10 times. Something is wrong, so I'm going to stop executing now.");
                        exit;
                    }

                    # This makes sure to repeat the upload until it finally succeeds.
                    # Hopefully helps fix a problem where some files aren't transferred.
                    $uploaded = @ftp_put($connection, $file, $file, FTP_BINARY);

                    if (!$uploaded) {
                        $attempts = $attempts + 1;
                        $this->output("Failed to upload {$file}. Retrying (attempt $attempts/10)... ");
                    }
                }
                $this->output("Uploaded {$file}");
            }

            foreach ($filesToDelete as $file) {
                @ftp_delete($connection, $file);
                $this->output("Deleted {$file}");
            }

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

                    foreach ($tmp_files as $file) {
                        ftp_delete($connection, $file);
                    }
                    $this->output("Emptied {$dir}");
                }
            }

            if (count($filesToUpload) > 0 or count($filesToDelete) > 0) {
                $this->output("----------------------------");
                $temp = tempnam(sys_get_temp_dir(), 'gitRevision');
                file_put_contents($temp, $revision);
                ftp_put($connection, 'REVISION', $temp, FTP_BINARY);
                unlink($temp);
                $this->output("Uploaded REVISION file.");

                # Upload file containing the current revision, for reverting when necessary.
                # But, only if the revision we're deploying is different from the one currently deployed.
                if ($remoteRevision != $revision) {
                    $temp = tempnam(sys_get_temp_dir(), 'gitRevision');
                    file_put_contents($temp, $remoteRevision);
                    ftp_put($connection, 'PREVIOUS_REVISION', $temp, FTP_BINARY);
                    unlink($temp);
                    $this->output("Uploaded PREVIOUS_REVISION file.");
                }
            } else {
                $this->output("No files to upload.");
            }
            
            $this->output( "----------------------------");

            $this->output("Finished working on {$server['host']}{$server['path']}");
            
            $this->output( "----------------------------");

            ftp_close($connection);
        }
    }

}