source: trunk/server/www/app/models/validator.php @ 349

<?php
/**
 * Officeshots.org - Test your office documents in different applications
 * Copyright (C) 2009 Stichting Lone Wolves
 * Written by Sander Marechal <s.marechal@jejik.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * The Validator model
 *
 * This model is an ODF Validator, not to be confused with the Validation class used for validating model data
 */
class Validator extends AppModel
{
        const STATE_PENDING     = 1;
        const STATE_VALID       = 2;
        const STATE_INVALID     = 3;
        const STATE_ERROR       = 4;

        /** @var array Model behaviors */
        public $actsAs = array(
                'Containable',
                'BeanStalk.Deferrable' => array('priority' => 2048),
        );

        /**
         * @var string The parent models.
         * This is a bit of a hack. They both refer to the same field but because the ID's are UUID they will never collide
         * and the right parent model should be picked automatically.
         * */
        public $belongsTo = array(
                'Request' => array('foreignKey' => 'parent_id'),
                'Result' => array('foreignKey' => 'parent_id'),
        );

        /**
         * Run the validator. Requires $this->id to be set.
         */
        public function run()
        {
                $this->log('Validating ID: ' . $this->id, LOG_DEBUG);

                if (!$this->id) {
                        return;
                }

                $this->read();
                if ($this->data['Request']['id']) {
                        $this->Request->id = $this->data['Request']['id'];
                        $file = $this->Request->getPath();
                        $destination = $this->data['Request']['path'];
                } else {
                        $this->Result->id = $this->data['Result']['id'];
                        $file = $this->Result->getPath();
                        $destination = $this->data['Result']['path'];
                }

                $className = $this->data['Validator']['name'] . 'Validator';
                if (!$this->data['Validator']['name'] || !class_exists($className)) {
                        $this->log('Invalid ODF Validator: ' . $this->data['Validator']['name'] . 'Validator');
                        return;
                }

                $validator = new $className();
                $validator->run($file);

                // Save the validator result to file
                $destination = FILES . $destination . DS . strtolower($this->data['Validator']['name']) . '-validator.' . $validator->ext;
                file_put_contents($destination, $validator->response);

                // Save the validator result to the satabase
                $this->data['Validator']['state']    = $validator->state;
                $this->data['Validator']['response'] = $validator->response;
                $this->save();
        }
}

/**
 * Validate an ODF document using the Cyclone3 stand-alone validator
 */
class CycloneValidator extends Object
{
        /** @var int The validator's state */
        public $state = Validator::STATE_PENDING;

        /** @var string The validator's full response */
        public $response = false;

        /** @var string Path to validator.pl */
        private $bin = false;

        /** @var string file extension for the response */
        public $ext = 'txt';

        /**
         * Run the validator
         * @var string $path Full path to the file to validate
         */
        public function run($path)
        {
                // Make sure the validator is configured
                $this->bin = Configure::read('Validator.Cyclone');
                if (!$this->bin || !is_executable($this->bin)) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('Cyclone validator "%s" not configured correctly.', $this->bin);
                        $this->log($this->response);
                        return;
                }

                // Make sure the file exists
                if (!is_readable($path)) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('File %s cannot be read.', $file);
                        $this->log($this->response);
                        return;
                }

                // Run Cyclone validator
                $cwd = getcwd();
                chdir(dirname($this->bin));

                $spec = array(
                        0 => array('pipe', 'r'), // STDIN
                        1 => array('pipe', 'w'), // STDOUT
                        2 => array('pipe', 'w')  // STDERR
                );

                $proc = proc_open($this->bin . ' "' . $path . '"', $spec, $pipes);
                if (!is_resource($proc)) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('Cyclone validator "%s" failed to execute.', $this->bin);
                        $this->log($this->response);
                        return;
                }

                $stdout = stream_get_contents($pipes[1]);
                $stderr = stream_get_contents($pipes[2]);
                fclose($pipes[0]);
                fclose($pipes[1]);
                fclose($pipes[2]);
                proc_close($proc);

                chdir($cwd);

                // Parse the results
                if (strpos($stdout, 'Result: VALID') != false) {
                        $this->state = Validator::STATE_VALID;
                        $this->log(sprintf('Cyclone: Validated %s: Valid', $path), LOG_DEBUG);
                } elseif (strpos($stdout, 'Result: INVALID') !== false) {
                        $this->state = Validator::STATE_INVALID;
                        $this->log(sprintf('Cyclone: Validated %s: Invalid', $path), LOG_DEBUG);
                } else {
                        $this->state = Validator::STATE_ERROR;
                        $this->log(sprintf("Cyclone: Validated %s: Error\nSTDOUT: %s\nSTDERR: %s", $path, $stdout, $stderr));
                }

                $this->response = $stdout;
        }
}

/**
 * Validate an ODF document using the Office-o-tron online validator
 */
class OfficeotronValidator extends Object
{
        /** @var int The validator's state */
        public $state = Validator::STATE_PENDING;

        /** @var string The validator's full response */
        public $response = false;

        /** @var string file extension for the response */
        public $ext = 'html';

        /**
         * Run the validator
         * @var string $path Full path to the file to validate
         */
        public function run($path)
        {
                // Make sure the validator is configured
                $endpoint = Configure::read('Validator.Officeotron');
                if (!$endpoint) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('Officeotron validator "%s" not configured correctly.', $endpoint);
                        $this->log($this->response);
                        return;
                }

                // Make sure the file exists
                if (!is_readable($path)) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('File %s cannot be read.', $file);
                        $this->log($this->response);
                        return;
                }

                // POST the file to Office-o-tron and get a response
                $curl = curl_init();
                curl_setopt($curl, CURLOPT_URL, $endpoint);
                curl_setopt($curl, CURLOPT_POST, true);
                curl_setopt($curl, CURLOPT_POSTFIELDS, file_get_contents($path));
                curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
                curl_setopt($curl, CURLOPT_TIMEOUT, 120);
                $this->response = curl_exec($curl);
                curl_close($curl);

                // No response, an error or a timeout
                if ($this->response === false) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('Officeotron: Could not get a response from %s. Error %d: %s', $endpoint, curl_errno($curl), curl_error($curl));
                        $this->log($this->response);
                        return;
                }

                if (preg_match('/Grand total count of validity errors: (\d+)/', $this->response, $match)) {
                        if ($match[1] == 0) {
                                $this->state = Validator::STATE_VALID;
                                $this->log(sprintf('Officeotron: Validated %s: Valid', $path), LOG_DEBUG);
                        } else {
                                $this->state = Validator::STATE_INVALID;
                                $this->log(sprintf('Officeotron: Validated %s: Invalid', $path), LOG_DEBUG);
                        }
                } else {
                        $this->state = Validator::STATE_ERROR;
                        $this->log(sprintf("Officeotron: Validated %s: Error:\n%s", $path, $this->response));
                }
        }
}

/**
 * A validator for Sun's ODFToolkit Validator.
 * NOTE: A bit ugly. It screen-scrapes the public online validator
 */
class ODFToolkitValidator extends Object
{
        /** @var int The validator's state */
        public $state = Validator::STATE_PENDING;

        /** @var string The validator's full response */
        public $response = false;

        /** @var string file extension for the response */
        public $ext = 'txt';

        /**
         * Run the validator
         * @var string $path Full path to the file to validate
         */
        public function run($path)
        {
                // Make sure the validator is configured
                $endpoint = Configure::read('Validator.ODFToolkit');
                if (!$endpoint) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('ODFToolkit validator "%s" not configured correctly.', $endpoint);
                        $this->log($this->response);
                        return;
                }

                // Make sure the file exists
                if (!is_readable($path)) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('File %s cannot be read.', $file);
                        $this->log($this->response);
                        return;
                }

                // POST the file to Office-o-tron and get a response
                $curl = curl_init();
                curl_setopt($curl, CURLOPT_URL, $endpoint);
                curl_setopt($curl, CURLOPT_POST, true);
                curl_setopt($curl, CURLOPT_POSTFIELDS, array(
                        'config' => 'auto',
                        'mode' => 0,
                        'loglevel' => 1,
                        'File1' => '@' . $path,
                ));
                curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
                curl_setopt($curl, CURLOPT_TIMEOUT, 120);
                $this->response = curl_exec($curl);
                curl_close($curl);

                // No response, an error or a timeout
                if ($this->response === false) {
                        $this->state = Validator::STATE_ERROR;
                        $this->response = sprintf('ODFToolkit: Could not get a response from %s. Error %d: %s', $endpoint, curl_errno($curl), curl_error($curl));
                        $this->log($this->response);
                        return;
                }

                // Parse the results
                if (strpos($this->response, 'This file is valid') != false) {
                        $this->state = Validator::STATE_VALID;
                        $this->response = 'This file is valid';
                        $this->log(sprintf('ODFToolkit: Validated %s: Valid', $path), LOG_DEBUG);
                } elseif (strpos($this->response, 'This file is NOT valid') !== false) {
                        $this->state = Validator::STATE_INVALID;
                        preg_match('#<pre>(.*)</pre>#s', $this->response, $match);
                        if (isset($match[1])) {
                                $this->response = $match[1];
                        }
                        $this->log(sprintf('ODFToolkit: Validated %s: Invalid', $path), LOG_DEBUG);
                } else {
                        $this->state = Validator::STATE_ERROR;
                        $this->log(sprintf("ODFToolkit: Validated %s: Error\nResponse: %s", $path, $this->response));
                }
        }
}

?>