Gendoria\CruftFlake\Config\ZooKeeperConfig

Complexity

Total Complexity

25

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	4
Bugs	0	Features	2

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	3
B	getMachine()	0	31	4
A	compareMachineInfo()	0	7	4
B	createMachineInfo()	0	27	4
B	getMachineInfo()	0	30	6
A	createParentIfNeeded()	0	13	2
A	machineToNode()	0	4	1
A	setLogger()	0	4	1

<?php

/**
 * ZooKeeper-based configuration.
 *
 * Couple of points:
 *
 *  1. We coordinate via ZK on launch - hence ZK must be available at launch
 *     time
 *  2. We create permanent nodes (not ephmeral) so that if we get disconnected
 *     ZK still knows about us running
 *  3. There is a danger that point 2 will mean that we run out of machine IDs
 *     if Mac Addresses change and we don't manually clean up
 *  4. This is assuming we don't run > 1 server on the same box - which we
 *     won't be able to do anyway since we bind to a ZeroMQ TCP port (which
 *     we can only do once)
 *
 * @author @davegardnerisme
 */

namespace Gendoria\CruftFlake\Config;

use BadMethodCallException;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use RuntimeException;

class ZooKeeperConfig implements ConfigInterface, LoggerAwareInterface
{
    /**
     * Parent path.
     *
     * @var string
     */
    private $parentPath;

    /**
     * ZK.
     *
     * @var \Zookeeper
     */
    private $zk;
    
    /**
     * Process ID for a multi-process-single-machine setup.
     * 
     * @var integer
     */
    private $procesId = 1;    

    /**
     * Logger.
     * 
     * @var LoggerInterface
     */
    private $logger;

    /**
     * Constructor.
     *
     * @param string          $hostnames A comma separated list of hostnames (including
     *                                   port)
     * @param integer           $processId If you want to run multiple server processes on a single machine, 
     *                                     you have to provide each one an unique ID,
     *                                     so the zookeeper knows, which machine ID belongs to which process.
     * @param string          $zkPath    The ZK path we look to find other machines under
     * @param LoggerInterface $logger    Logger class
     */
    public function __construct($hostnames, $processId = 1, $zkPath = '/cruftflake', LoggerInterface $logger = null)
    {
        if (!class_exists('\Zookeeper')) {
            $this->logger->critical('Zookeeper not present');
            throw new BadMethodCallException(
            'ZooKeeper extension not installed. Try hitting PECL.'
            );
        }
        $this->procesId = $processId;
        $this->zk = new \Zookeeper($hostnames);
        $this->parentPath = $zkPath;
        if ($logger) {
            $this->logger = $logger;
        } else {
            $this->logger = new NullLogger();
        }
    }

    /**
     * Get machine identifier.
     *
     * @return int Should be a 10-bit int (decimal 0 to 1023)
     * @throws RuntimeException Thrown, when obtaining machine ID has failed.
     */
    public function getMachine()
    {
        $machineId = null;

        $this->createParentIfNeeded($this->parentPath);

        // get info about _this_ machine
        $machineInfo = $this->getMachineInfo();

        // get current machine list
        $children = $this->zk->getChildren($this->parentPath);
        
        //Find existing machine info
        foreach ($children as $child) {
            $info = $this->zk->get("{$this->parentPath}/$child");
            $info = json_decode($info, true);
            if ($this->compareMachineInfo($info, $machineInfo)) {
                $machineId = (int) $child;
                break; //We don't have to check further
            }
        }
        
        //Machine info not found, attempt to create one
        if ($machineId === null) {
            $machineId = $this->createMachineInfo($children, $machineInfo);
        }

        $this->logger->debug('Obtained machine ID '.$machineId.' through ZooKeeper configuration');

        return (int) $machineId;
    }
    
    /**
     * Compare found machine information with expected values.
     * 
     * @param array $found
     * @param array $expected
     * @return boolean
     */
    private function compareMachineInfo(array $found, array $expected)
    {
        if (!isset($found['macAddress']) || !isset($found['processId'])) {
            return false;
        }
        return ($found['macAddress'] === $expected['macAddress'] && $found['processId'] === $expected['processId']);
    }
    
    /**
     * Attempt to claim and create new machine ID in Zookeeper.
     * 
     * @param array $children
     * @param array $machineInfo
     * @return integer Machine ID.
     * @throws RuntimeException Thrown, when creation of machine ID has failed.
     */
    private function createMachineInfo(array $children, array $machineInfo)
    {
        // find an unused machine number
        for ($i = 0; $i < 1024; ++$i) {
            $machineNode = $this->machineToNode($i);
            if (in_array($machineNode, $children)) {
                continue; // already used
            }

            // attempt to claim
            $created = $this->zk->create(
                "{$this->parentPath}/{$machineNode}", json_encode($machineInfo),
                array(array(// acl
                    'perms' => \Zookeeper::PERM_ALL,
                    'scheme' => 'world',
                    'id' => 'anyone',
                ))
            );
            if ($created !== null) {
                return $i;
            }
        }
        
        //Creating machine ID failed, throw an error
        $this->logger->critical('Cannot locate and claim a free machine ID via ZK', array($this));
        throw new RuntimeException('Cannot locate and claim a free machine ID via ZK');
    }

    /**
     * Get mac address and hostname.
     *
     * @return array "macAddress", "hostname" keys
     */
    private function getMachineInfo()
    {
        $info = array();
        $output = array();
        // Possible responses are: HWaddr 12:31:3c:01:65:b8, ether 00:1c:42:00:00:08
        exec('ifconfig', $output);
        if ($output == null) {
            $output = array();
        }
        foreach ($output as $o) {
            $matched = array();
            if (preg_match('/(HWaddr|ether) ([a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2}:[a-f0-9]{2})/i',
                    $o, $matched)) {
                $info['macAddress'] = $matched[2];
                break;
            }
        }
        $info['hostname'] = exec('hostname');

        if (empty($info['hostname']) || empty($info['macAddress'])) {
            $this->logger->critical('Unable to identify machine mac address and hostname',
                array($this));
            throw new RuntimeException(
            'Unable to identify machine mac address and hostname'
            );
        }
        $info['processId'] = $this->procesId;

        return $info;
    }

    /**
     * Create parent node, if needed.
     *
     * @param string $nodePath
     */
    private function createParentIfNeeded($nodePath)
    {
        if (!$this->zk->exists($nodePath)) {
            $this->zk->create(
                $nodePath, 'Cruftflake machines',
                array(array(// acl
                    'perms' => \Zookeeper::PERM_ALL,
                    'scheme' => 'world',
                    'id' => 'anyone',
                ))
            );
        }
    }

    /**
     * Machine ID to ZK node.
     *
     * @param int $id
     *
     * @return string The node path to use in ZK
     */
    private function machineToNode($id)
    {
        return str_pad($id, 4, '0', STR_PAD_LEFT);
    }

    /**
     * Set logger.
     * 
     * @param LoggerInterface $logger
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
}