Soap\ParallelSoapClient

Complexity

Total Complexity

58

Size/Duplication

Total Lines	609
Duplicated Lines	0 %

Test Coverage

Coverage

64.39%

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	getLogger()	0	3	1
A	getCurlOptions()	0	3	1
A	isLogSoapRequest()	0	3	1
A	setLogPrettyXml()	0	4	1
A	isLogPrettyXml()	0	3	1
A	setLogSoapRequest()	0	4	1
A	setCurlOptions()	0	4	1
A	setDebugFn()	0	4	1
A	getDebugFn()	0	3	1
A	setLogger()	0	4	1
A	setMulti()	0	4	1
A	getMulti()	0	3	1
B	__construct()	0	32	1
A	getSoapActionFn()	0	3	1
A	setResFn()	0	4	1
A	getResFn()	0	3	1
A	setSoapActionFn()	0	4	1
A	callParallel()	0	20	2
A	callOne()	0	12	2
A	prettyXml()	0	8	1
B	getMultiResponses()	0	33	4
D	doRequests()	0	58	14
A	getResponseResult()	0	17	2
A	__call()	0	9	2
B	run()	0	30	6
A	addDebugData()	0	4	1
C	__doRequest()	0	72	7

<?php

namespace Soap;

use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

/**
 * Single/Parallel Soap Class
 *
 * Implements soap with multi server-to-server calls using curl module.
 *
 * @author Mohamed Meabed <mo.meabed@gmail.com>
 * @link   https://github.com/Meabed/php-parallel-soap
 * @note   Check the Example files and read the documentation carefully
 */
class ParallelSoapClient extends \SoapClient
{
    /**  array of all responses in the client */
    public $soapResponses = [];

    /**  array of all requests in the client */
    public $soapRequests = [];

    /**  array of all requests xml in the client */
    public $requestXmlArr = [];

    /**  string the xml returned from soap call */
    public $xmlResponse;

    /**  string current method call  */
    public $soapMethod;

    /** @var array of all requests soap methods in the client */
    public $soapMethodArr = [];

    /**  array of all requestIds  */
    public $requestIds;

    /**  string last request id  */
    public $lastRequestId;

    /**  bool soap parallel flag  */
    public $multi = false;

    /** @var bool log soap request */
    public $logSoapRequest = false;

    /** @var bool log pretty xml */
    public $logPrettyXml = false;

    /**  array of all curl_info in the client */
    public $curlInfo = [];

    /** @var array curl options */
    public $curlOptions = [];

    /** @var \Closure */
    protected $debugFn;

    /** @var \Closure */
    protected $resFn;

    /** @var \Closure */
    protected $soapActionFn;

    /** @var LoggerInterface */
    public $logger;

    /**
     * @var array
     */
    public $sharedCurlData = [];

    /**  getRequestResponse action constant used for parsing the xml with from parent::__doRequest */
    const GET_RESPONSE_CONST = 'getRequestResponseMethod';
    const ERROR_STR = '*ERROR*';


    /**
     * @return mixed
     */
    public function getMulti()
    {
        return $this->multi;
    }

    /**
     * @param mixed $multi
     * @return ParallelSoapClient
     */
    public function setMulti($multi)
    {
        $this->multi = $multi;
        return $this;
    }

    /**
     * @return array
     */
    public function getCurlOptions()
    {
        return $this->curlOptions;
    }

    /**
     * @param array $curlOptions
     * @return ParallelSoapClient
     */
    public function setCurlOptions(array $curlOptions)
    {
        $this->curlOptions = $curlOptions;
        return $this;
    }

    /**
     * @return LoggerInterface
     */
    public function getLogger()
    {
        return $this->logger;
    }

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

    /**
     * @return bool
     */
    public function isLogSoapRequest()
    {
        return $this->logSoapRequest;
    }

    /**
     * @param bool $logSoapRequest
     * @return ParallelSoapClient
     */
    public function setLogSoapRequest(bool $logSoapRequest)
    {
        $this->logSoapRequest = $logSoapRequest;
        return $this;
    }

    /**
     * @return bool
     */
    public function isLogPrettyXml()
    {
        return $this->logPrettyXml;
    }

    /**
     * @param bool $logPrettyXml
     * @return ParallelSoapClient
     */
    public function setLogPrettyXml(bool $logPrettyXml)
    {
        $this->logPrettyXml = $logPrettyXml;
        return $this;
    }

    /**
     * @return \Closure
     */
    public function getDebugFn()
    {
        return $this->debugFn;
    }

    /**
     * @param \Closure $debugFn
     * @return ParallelSoapClient
     */
    public function setDebugFn(\Closure $debugFn)
    {
        $this->debugFn = $debugFn;
        return $this;
    }

    /**
     * @return \Closure
     */
    public function getResFn()
    {
        return $this->resFn;
    }

    /**
     * @param \Closure $resFn
     * @return ParallelSoapClient
     */
    public function setResFn(\Closure $resFn)
    {
        $this->resFn = $resFn;
        return $this;
    }

    /**
     * @return \Closure
     */
    public function getSoapActionFn()
    {
        return $this->soapActionFn;
    }

    /**
     * @param \Closure $soapActionFn
     * @return ParallelSoapClient
     */
    public function setSoapActionFn(\Closure $soapActionFn)
    {
        $this->soapActionFn = $soapActionFn;
        return $this;
    }


    public function __construct($wsdl, array $options = null)
    {
        parent::__construct($wsdl, $options);

        // logger
        $logger = $options['logger'] ?? new NullLogger();
        $this->setLogger($logger);

        // debug function to add headers / last request / response / etc...
        $debugFn = $options['debugFn'] ?? function ($res, $id) {

The parameter $id is not used and could be removed.

The parameter $res is not used and could be removed.

            };
        $this->setDebugFn($debugFn);

        // result parsing function
        $resFn = $options['resFn'] ?? function ($method, $res) {
                return $res;
            };
        $this->setResFn($resFn);

        // soapaction function to set in the header
        $soapActionFn = $options['soapActionFn'] ?? function ($action, $headers) {
                $headers[] = 'SOAPAction: "' . $action . '"';
                // 'SOAPAction: "' . $soapAction . '"', pass the soap action in every request from the WSDL if required
                return $headers;
            };
        $this->setSoapActionFn($soapActionFn);

        // cleanup
        unset($options['logger']);
        unset($options['debugFn']);
        unset($options['resFn']);
        unset($options['soapActionFn']);
    }

    /**
     * Soap __doRequest() Method with CURL Implementation
     *
     * @param string $request The XML SOAP request
     * @param string $location The URL to request
     * @param string $action The SOAP action
     * @param int $version The SOAP version
     * @param int $one_way If one_way is set to 1, this method returns nothing. Use this where a response is not expected
     *
     * @return string
     * @throws \Exception|\SoapFault
     */
    public function __doRequest($request, $location, $action, $version, $one_way = 0)
    {
        $shouldGetResponse = ($this->soapMethod == static::GET_RESPONSE_CONST);

        // print xml for debugging testing
        if ($this->logSoapRequest) {
            // debug the request here
            if ($this->isLogPrettyXml()) {
                $this->logger->debug($this->prettyXml($request));
            } else {
                $this->logger->debug($request);
            }
        }
        // some .NET Servers only accept action method with ns url!! uncomment it if you get error wrong command
        /** return the xml response as its coming from normal soap call */
        if ($shouldGetResponse && $this->xmlResponse) {
            return $this->xmlResponse;
        }

        $soapRequests = &$this->soapRequests;

        /** @var $id string represent hashId of each request based on the request body
         * to avoid multiple calls for the same request if exists
         */
        $id = sha1($location . $request);

        /** @var $headers array of headers to be sent with request */
        $defaultHeaders = [
            'Content-type: text/xml',
            'charset=utf-8',
            "Accept: text/xml",
            "Content-length: " . strlen($request),
        ];

        // pass the soap action in every request from the WSDL if required
        $soapActionFn = $this->soapActionFn;
        $headers = $soapActionFn($action, $defaultHeaders);

        // ssl connection sharing
        if (empty($this->sharedCurlData[$location])) {
            $shOpt = curl_share_init();
            curl_share_setopt($shOpt, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
            curl_share_setopt($shOpt, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
            curl_share_setopt($shOpt, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
            $this->sharedCurlData[$location] = $shOpt;
        }

        $sh = $this->sharedCurlData[$location];

        $ch = curl_init();
        /** CURL_OPTIONS  */
        curl_setopt($ch, CURLOPT_URL, $location);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_SHARE, $sh);

        // assign curl options
        foreach ($this->curlOptions as $key => $value) {
            curl_setopt($ch, $key, $value);
        }

        $soapRequests[$id] = $ch;

        $this->requestIds[$id] = $id;
        $this->soapMethodArr[$id] = $this->soapMethod;
        $this->requestXmlArr[$id] = $request;
        $this->lastRequestId = $id;

        return "";
    }

    /**
     * Call Sync method, act like normal soap method with extra implementation if needed
     * @param string $method
     * @param string $args
     * @throws \Exception|\SoapFault
     * @return string|mixed
     */
    public function callOne($method, $args)
    {
        try {
            parent::__call($method, $args);
            /** parse the xml response or throw an exception */
            $this->xmlResponse = $this->run([$this->lastRequestId]);
            $res = $this->getResponseResult($method, $args);
        } catch (\Exception $e) {
            throw $e;
        }

        return $res;
    }

    /**
     * Call Parallel method, suppress exception and convert to string
     * @param string $method
     * @param string $args
     * @return string|mixed
     */
    public function callParallel($method, $args)
    {
        /** generate curl session and add the soap requests to execute it later  */
        try {
            parent::__call($method, $args);
            /**
             * Return the Request ID to the calling method
             * This next 2 lines should be custom implementation based on your solution.
             *
             * @var $res string ,On multiple calls Simulate the response from Soap API to return the request Id of each call
             * to be able to get the response with it
             * @note check the example file to understand what to write here
             */
            $res = $this->lastRequestId;
        } catch (\Exception $ex) {
            /** catch any SoapFault [is not a valid method for this service] and return null */
            $res = self::ERROR_STR . ':' . $method . ' - ' . $ex->getCode() . ' - ' . $ex->getMessage() . ' - rand::' . rand();
        }

        return $res;
    }

    /**
     * __call Magic method to allow one and Parallel Soap calls with exception handling
     *
     * @param string $method
     * @param string $args
     *
     * @return string|mixed
     * @throws \Exception
     * @throws \SoapFault
     */
    public function __call($method, $args)
    {
        /** set current action to the current method call */
        $this->soapMethod = $method;

        if (!$this->multi) {
            return $this->callOne($method, $args);
        } else {
            return $this->callParallel($method, $args);
        }
    }

    /**
     * Execute all or some items from $this->soapRequests
     *
     * @param mixed $requestIds
     * @param bool $partial
     */
    public function doRequests($requestIds = [], $partial = false)
    {
        $allSoapRequests = &$this->soapRequests;
        $soapResponses = &$this->soapResponses;

        /** Determine if its partial call to execute some requests or execute all the request in $soapRequests array otherwise */
        if ($partial) {
            $soapRequests = array_intersect_key($allSoapRequests, array_flip($requestIds));
        } else {
            $soapRequests = &$this->soapRequests;
        }

        /** Initialise curl multi handler and execute the requests  */
        $mh = curl_multi_init();
        foreach ($soapRequests as $ch) {
            curl_multi_add_handle($mh, $ch);
        }

        $active = null;
        do {
            $mrc = curl_multi_exec($mh, $active);
        } while ($mrc === CURLM_CALL_MULTI_PERFORM || $active);

        while ($active && $mrc == CURLM_OK) {
            if (curl_multi_select($mh) != -1) {
                do {
                    $mrc = curl_multi_exec($mh, $active);
                } while ($mrc == CURLM_CALL_MULTI_PERFORM);
            }
        }
        /** assign the responses for all requests has been performed */
        foreach ($soapRequests as $id => $ch) {
            try {
                $soapResponses[$id] = curl_multi_getcontent($ch);
                // todo if config
                $curlInfo = curl_getinfo($ch);
                if ($curlInfo) {
                    $this->curlInfo[$id] = (object)$curlInfo;
                }

                // @link http://stackoverflow.com/questions/14319696/soap-issue-soapfault-exception-client-looks-like-we-got-no-xml-document
                if ($soapResponses[$id] === null) {
                    throw new \SoapFault("HTTP", curl_error($ch));

curl_error($ch) of type string is incompatible with the type integer expected by parameter $code of SoapFault::__construct().

                }
            } catch (\Exception $e) {
                $soapResponses[$id] = $e;
            }
            curl_multi_remove_handle($mh, $ch);
            curl_close($ch);
        }
        curl_multi_close($mh);

        /** unset the request performed from the class instance variable $soapRequests so we don't request them again */
        if (!$partial) {
            $soapRequests = [];
        }
        foreach ($soapRequests as $id => $ch) {
            unset($allSoapRequests[$id]);
        }
    }

    /**
     * Main method to perform all or some Soap requests
     *
     * @param array $requestIds
     *
     * @return string $res
     */
    public function run($requestIds = [])
    {
        $partial = false;

        if (is_array($requestIds) && count($requestIds)) {
            $partial = true;
        }
        $allSoapResponses = &$this->soapResponses;

        /** perform all the request */
        $this->doRequests($requestIds, $partial);

        /** reset the class to synchronous mode */
        $this->setMulti(false);

        /** parse return response of the performed requests  */
        if ($partial) {
            $soapResponses = array_intersect_key($allSoapResponses, array_flip($requestIds));
        } else {
            $soapResponses = &$this->soapResponses;
        }
        /** if its one request return the first element in the array */
        if ($partial && count($requestIds) == 1) {
            $res = $soapResponses[$requestIds[0]];
            unset($allSoapResponses[$requestIds[0]]);
        } else {
            $res = $this->getMultiResponses($soapResponses);
        }

        return $res;
    }

    /**
     * Parse Response of Soap Requests with parent::__doRequest()
     *
     * @param array $responses
     *
     * @return mixed $resArr
     */
    public function getMultiResponses($responses = [])
    {
        $resArr = [];
        $this->soapMethod = static::GET_RESPONSE_CONST;

        foreach ($responses as $id => $ch) {
            try {
                $this->xmlResponse = $ch;
                if ($ch instanceof \Exception) {
                    throw $ch;
                }
                $res = parent::__call($this->soapMethodArr[$id], []);

array() of type array is incompatible with the type string expected by parameter $arguments of SoapClient::__call().

                /**
                 * Return the Request ID to the calling method
                 * This next lines should be custom implementation based on your solution.
                 *
                 * @var $resArr string ,On multiple calls Simulate the response from Soap API to return the request Id of each call
                 * to be able to get the response with it
                 * @note check the example file to understand what to write here
                 */
                $resFn = $this->resFn;
                $resArr[$id] = $resFn($this->soapMethodArr[$id], $res);
                $this->addDebugData($res, $id);
            } catch (\Exception $ex) {
                $this->addDebugData($ex, $this->lastRequestId);
                $resArr[$id] = $ex;
            }
            unset($this->soapResponses[$id]);
        }
        $this->xmlResponse = '';
        $this->soapMethod = '';

        return $resArr;
    }

    /**
     * Parse Response of Soap Requests with parent::__doRequest()
     *
     * @param string $method
     * @param string|array $args
     *
     * @throws \Exception|\SoapFault|
     * @return string $res
     */
    public function getResponseResult($method, $args)
    {
        $this->soapMethod = static::GET_RESPONSE_CONST;

        try {
            $res = parent::__call($method, $args);

It seems like $args can also be of type array; however, parameter $arguments of SoapClient::__call() does only seem to accept string, maybe add an additional type check?

            $id = $this->lastRequestId;
            $this->addDebugData($res, $id);
        } catch (\Exception $ex) {
            $this->addDebugData($ex, $this->lastRequestId);
            throw $ex;
        }
        $this->soapMethod = '';

        $resFn = $this->resFn;
        return $resFn($method, $res);
    }


    /**
     * Add curl info to response object
     *
     * @param $res
     * @param $id
     *
     * @author Mohamed Meabed <mohamed.meabed@tajawal.com>
     *
     */
    public function addDebugData($res, $id)
    {
        $fn = $this->debugFn;
        $fn($res, $id);
    }

    /**
     * Print pretty xml
     *
     * @param $request
     *
     * @return string
     *
     * @author Mohamed Meabed <mohamed.meabed@tajawal.com>
     *
     */
    public function prettyXml($request)
    {
        $dom = new \DOMDocument();
        $dom->preserveWhiteSpace = false;
        $dom->loadXML($request);
        $dom->formatOutput = true;

        return $dom->saveXml();
    }
}