ManagesTransactions::executeTransaction() - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/Larave..." - LaravelFreelancerNL/laravel-arangodb - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Push — master ( 11c8ec...b620eb )

by Bas
created 2020-12-15 17:52 UTC
ManagesTransactions::executeTransaction() A

↳ Parent: ManagesTransactions
Complexity

Conditions	3
Paths	3
Size

Total Lines	18
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	7
CRAP Score	3.243
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	10
c	1
b	0
f	0
dl	0
loc	18
ccs	7
cts	10
cp	0.7
rs	9.9332
cc	3
nc	3
nop	2
crap	3.243
<?php

namespace LaravelFreelancerNL\Aranguent\Concerns;

use ArangoDBClient\Transaction as ArangoTransaction;
use Closure;
use Exception;
use Illuminate\Support\Fluent as IlluminateFluent;

trait ManagesTransactions
{
    protected $transactions = 0;

    protected $transactionCommands = [];

    protected $arangoTransaction;

    /**
     * Execute a Closure within a transaction.
     *
     * @param \Closure $callback
     * @param array    $options
     * @param int      $attempts
     *
     * @throws \Exception|\Throwable
     *
     * @return mixed
     */
    public function transaction(Closure $callback, $options = [], $attempts = 1)
    {
        $this->beginTransaction();

        return tap($callback($this), function () use ($options, $attempts) {
            $this->commit($options, $attempts);
        });
    }

    /**
     * Start a new database transaction.
     *
     * @throws \Exception
     *
     * @return void
     */
    public function beginTransaction()
    {
        $this->transactions++;

        $this->transactionCommands[$this->transactions] = [];

        $this->fireConnectionEvent('beganTransaction');
               fireConnectionEvent('beganTransaction');
    }

    /**
     * Add a command to the transaction. Parameters must include:
     * collections['write'][]: collections that are written to
     * collections['read'][]: collections that are read from
     * command: the db command to execute.
     *
     * @param \Illuminate\Support\Fluent $command
     */
    public function addTransactionCommand(IlluminateFluent $command)
    {
        $this->transactionCommands[$this->transactions][] = $command;
    }

    /**
     * Add a query command to the transaction.
     *
     * @param $query
     * @param $bindings
     * @param array|null $collections
     *
     * @return IlluminateFluent
     */
    public function addQueryToTransaction($query, $bindings = [], $collections = [])
    {
        [$query, $bindings, $collections] = $this->handleQueryBuilder($query, $bindings, $collections);
        [$query, $bindings, $collections] = $this->handleQueryBuilder($query, $bindings, $collections);

         $jsCommand = 'db._query(aql`' . $query . '`';
        if (!empty($bindings)) {
            $bindings = json_encode($bindings);
            $jsCommand .= ', ' . $bindings;
        }
        $jsCommand .= ');';
        $command = new IlluminateFluent([
            'name'        => 'aqlQuery',
            'command'     => $jsCommand,
            'collections' => $collections,
        ]);

        $this->addTransactionCommand($command);

        return $command;
    }

    /**
     * Commit the current transaction.
     *
     * @param array $options
     * @param int   $attempts
     *
     * @throws Exception
     *
     * @return mixed
     */
    public function commit($options = [], $attempts = 1)
    {
        if (!$this->transactions > 0) {
            throw new Exception('Transaction committed before starting one.');
        }
        if (
            !isset($this->transactionCommands[$this->transactions])
            || empty($this->transactionCommands[$this->transactions])
        ) {
            throw new Exception('Cannot commit an empty transaction.');
        }

        $options['collections'] = $this->compileTransactionCollections();

        $options['action'] = $this->compileTransactionAction();

        $results = $this->executeTransaction($options, $attempts);

        $this->fireConnectionEvent('committed');

        return $results;
    }

    public function executeTransaction($options, $attempts = 1)
    {
        $results = null;

        $this->arangoTransaction = new ArangoTransaction($this->arangoConnection, $options);
        for ($currentAttempt = 1; $currentAttempt <= $attempts; $currentAttempt++) {
            try {
                $results = $this->arangoTransaction->execute();

                $this->transactions--;
            } catch (Exception $e) {
                $this->fireConnectionEvent('rollingBack');

                $results = $this->handleTransactionException($e, $currentAttempt, $attempts);
            }
        }

        return $results;
    }

    /**
     * Handle an exception encountered when running a transacted statement.
     *
     * @param $e
     * @param $currentAttempt
     * @param $attempts
     *
     * @return mixed
     */
    protected function handleTransactionException($e, $currentAttempt, $attempts)
    {
        $retry = false;
        // If the failure was due to a lost connection we can just try again.
        if ($this->causedByLostConnection($e)) {
        if ($this->/** @scrutinizer ignore-call */ causedByLostConnection($e)) {
            $this->reconnect();
                   reconnect();
            $retry = true;
        }

        // Retry if the failure was caused by a deadlock or ArangoDB suggests we try so.
        // We can check if we have exceeded the maximum attempt count for this and if
        // we haven't we will return and try this transaction again.
        if (
            $this->causedByDeadlock($e) &&
                   causedByDeadlock($e) &&
            $currentAttempt < $attempts
        ) {
            $retry = true;
        }

        if ($retry) {
            return $this->arangoTransaction->execute();
        }

        throw $e;
    }

    /**
     * compile an array of unique collections that are used to read from and/or write to.
     *
     * @return array
     */
    public function compileTransactionCollections()
    {
        $result['write'] = [];

        $result['read'] = [];

        $commands = $this->transactionCommands[$this->transactions];

        foreach ($commands as $command) {
            if (isset($command->collections['write'])) {
                $write = $command->collections['write'];
                if (is_string($write)) {
                    $write = (array) $write;
                }
                $result['write'] = array_merge($result['write'], $write);
            }
            if (isset($command->collections['read'])) {
                $read = $command->collections['read'];
                if (is_string($read)) {
                    $read = (array) $read;
                }
                $result['read'] = array_merge($result['write'], $read);
            }
        }

        $result['read'] = array_merge($result['read'], $result['write']);

        $result['write'] = array_filter(array_unique($result['write']));
        if (empty($result['write'])) {
            unset($result['write']);
        }

        $result['read'] = array_filter(array_unique($result['read']));
        if (empty($result['read'])) {
            unset($result['read']);
        }

        $result = array_filter($result);

        return $result;
    }

    public function compileTransactionAction()
    {
        $commands = collect($this->transactionCommands[$this->transactions]);

        $action = "function () { var db = require('@arangodb').db; ";
        $action .= $commands->implode('command', ' ');
        $action .= ' }';

        return $action;
    }

    /**
     * Handle an exception from a rollback.
     *
     * @param \Exception $e
     *
     * @throws \Exception
     */
    protected function handleRollBackException($e)
    {
        if ($this->causedByLostConnection($e)) {
            $this->transactions = 0;
        }

        throw $e;
    }

    /**
     * Get the number of active transactions.
     *
     * @return int
     */
    public function transactionLevel()
    {
        return $this->transactions;
    }

    public function getTransactionCommands()
    {
        return $this->transactionCommands;
    }

    //Override unused trait transaction functions with dummy methods

//    /**
//     * Dummy.
//     *
//     * @param $e
//     */
//    public function handleBeginTransactionException($e)
//    {
//        //
//    }

//    /**
//     * Dummy override: Rollback the active database transaction.
//     *
//     * @param int|null $toLevel
//     *
//     * @throws \Exception
//     *
//     * @return void
//     */
//    public function rollBack($toLevel = null)
//    {
//        //
//    }
//
//    /**
//     * Dummy override: ArangoDB rolls back the entire transaction on a failure.
//     *
//     * @param int $toLevel
//     *
//     * @return void
//     */
//    protected function performRollBack($toLevel)
//    {
//        //
//    }
//
//    /**
//     * Create a save point within the database.
//     * Not supported by ArangoDB(?).
//     *
//     * @return void
//     */
//    protected function createSavepoint()
//    {
//        //
//    }
}

LaravelFreelancerNL / laravel-arangodb

Push — master ( 11c8ec...b620eb )

ManagesTransactions::executeTransaction() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
