Een development blog voor een crypto trading bot

<?php
    /*
        The MIT License (MIT)

        Copyright (c) 2018 Jaap van Wingerden

        Permission is hereby granted, free of charge, to any person obtaining a copy
        of this software and associated documentation files (the "Software"), to deal
        in the Software without restriction, including without limitation the rights
        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        copies of the Software, and to permit persons to whom the Software is
        furnished to do so, subject to the following conditions:

        The above copyright notice and this permission notice shall be included in all
        copies or substantial portions of the Software.

        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
        SOFTWARE.
    */

    /*
    * This class is meant to be a replacement for the Thread class provided
    * by PHP's PThread extension that does not depend on PThreads to be installed,
    * but instead emulates threads by starting code in a new PHP process.
    */
    if (!class_exists('Thread')){
        abstract class Thread implements Serializable {
            private $creatorPid;
            private $childPid;
            private $childName;
            private $started = false;
            private $myClassDefinition;
            
            /*
            * Determine if this is the parent or a running child thread.
            */
            private function isThread(){
                return (getmypid() == $this->getPidByProcessName($this->childName));
            }
            
            /*
            * Takes a process name and returns a PID (ps has to be installed in order for this to work).
            */
            private function getPidByProcessName($processName){
                exec(sprintf("ps aux | grep '%s' | grep -v grep | awk '{ print $2 }' | head -1", $processName), $out);
                if (is_array($out))
                    if (array_key_exists(0, $out))
                        if (is_numeric($out[0]))
                            return $out[0];
                return false;
            }
            
            /*
            * Implementation of Serializable interface.
            * Makes sure that child objects are also serialized when teleporting.
            */
            public function serialize(){ 
                $result = array();
                foreach(get_object_vars($this) as $key => $value){
                    $mirror = new ReflectionClass($this);
                    if (is_object($value)){
                        $mirror = new \ReflectionClass($value);
                    }
                    $result[$key] = array(
                        'data' => is_object($value) ? serialize($value) : $value,
                        'serialized' => is_object($value),
                        'include' => $mirror->getFileName(),
                    );
                }
                $result = serialize($result);
                return $result;
            }
            
            /*
            * Implementation of Serializable interface.
            * Unserialize child objects too.
            */
            public function unserialize($serialized){ 
                $data = unserialize($serialized);
                foreach ($data as $key => $value){
                    if ($value['serialized']){
                        include_once($value['include']);
                    }
                    $this->$key = $value['serialized'] ? unserialize($value['data']) : $value['data'];
                }
            }
            
            /*
            * Constructor. Save the (parent) PID.
            */
            function __construct(){
                // Set the creator ID to the current PID upon instantiation.
                // The new thread will be this class instance serialized into a new process.
                $this->creatorPid = getmypid();
            }
            
            /*
            * Since detach() has been removed as of pThreads v3, this class
            * only implements it as a bogus function.
            */
            public function detach(){
                
            }
            
            /*
            * The creator ID will be the PID of the parent process for now.
            */
            public function getCreatorId(){
                return $this->creatorPid;
            }
            
            /*
            * According to PHP documentation:
            * "Return a reference to the currently executing Thread"
            *
            * But since this implementation runs it's thread in a separate process,
            * that's not possible, so return false.
            */
            public function getCurrentThread(){
                return false;
            }
            
            /*
            * According to PHP documentation:
            * "Will return the identity of the currently executing Thread"
            *
            * In this case, the (unique) process name will have to do as "identity".
            */
            public function getCurrentThreadId(){
                return $this->childName;
            }
            
            /*
            * Hmm, what shall we do with this one?
            */
            public function getThreadId(){
                $result = $this->getCurrentThreadId();
                return $result;
            }
            
            /*
            * BOGUS IMPLEMENTATION.
            * According to PHP docs:
            * 
            * Warning: This method has been removed in pthreads v3.
            */
            public static function globally(){
                return false;
            }
            
            /*
            * Determines if the child thread has ended.
            */
            public function isJoined(){
                if (!$this->isStarted()){
                    return false;
                }
                if (is_numeric($this->childPid)){ // If started is true, and a PID id was stored, return the state of that PID.
                    if (is_numeric($this->getPidByProcessName($this->childName)))
                        return false;
                    return true;
                }
                // If started is true, but no PID id is set, then this instance is probably the thread, so return false (we're running!).
                return false;
            }
            
            /*
            * Did the child thread ever start?
            */
            public function isStarted(){
                return $this->started;
            }
            
            /*
            * This will keep the parent process busy until the child process exits.
            */
            public function join(){
                if ($this->isThread()) return;
                while(!$this->isJoined()){
                    usleep(250000);
                }
            }
            
            /*
            * Die, evil child thread!
            */
            public function kill(){
                if (!$this->isStarted())
                    return false;
                if ($this->isJoined())
                    return false;
                if (is_numeric($this->childPid)){
                    $result = posix_kill($this->childPid, SIGKILL);
                    return $result;
                }
                // Kill the current thread!
                die();
            }
            
            /*
            * materialize() is called right after this class has been teleported to the child process
            * and is responsible for initializing some values and executing the run() function
            * which should be implemented in the inheriting class.
            */
            public function materialize(){
                $this->childPid = (int)$this->getPidByProcessName($this->childName);
                $this->run();
            }
            
            /*
            * Start the child process.
            */
            public function start(){
                $this->started = true; // So isStarted() will know.
                $this->childName = microtime(). "phpthread"; // Create a name for the child process.
                $mirror = new ReflectionClass($this); // This is needed to get some info about the current class instance.
                
                /*
                * This process of starting a thread works by piping some bootstrapping code to the
                * PHP executable. The bootstrapping code makes sure to include the nessecary files, unserializes
                * this class and calls the materialize() function.
                */
                $teleportcode = escapeshellarg(sprintf('<?php set_include_path("%s"); include_once("%s"); cli_set_process_title("%s"); $scr = unserialize(base64_decode("%s")); $scr->materialize();', addslashes(pathinfo($mirror->getFileName(), PATHINFO_DIRNAME)), addslashes($mirror->getFileName()), $this->childName, base64_encode(serialize($this))));
                $teleportcommand = '/bin/echo '. $teleportcode . ' | '.  PHP_BINARY . ' >> logthreads.txt &';
                exec($teleportcommand);
                sleep(5); // Some delay to allow the child process to initialize and set it's proces name.
                $this->childPid = $this->getPidByProcessName($this->childName);
            }
        }
    }

FROM php:7.1-cli

# PHP Extension: mysqli
RUN docker-php-ext-install mysqli && docker-php-ext-enable mysqli

# PHP Extension: Gearman
# Download Gearman PECL extension for Gearman supporting PHP 7
RUN apt-get update\
    && apt-get -y --allow-unauthenticated install libgearman-dev git
RUN cd /tmp \  
    && git clone https://github.com/wcgallego/pecl-gearman.git \
    && cd pecl-gearman \
    && git checkout gearman-2.0.3 \
    && phpize \
    && ./configure \
    && make \
    && make install \
    && apt-get remove -y --purge git \
    && apt-get -y autoremove
RUN docker-php-ext-enable gearman