vector clock

Biblioteca PHP de marca vectorial y lamport PHP

Este proyecto es una implementación de PHP del concepto de reloj vectorial y la marca de tiempo de Lamport como se define en el documento: marcas de tiempo en los sistemas de pasada de mensajes que preservan el pedido parcial (papel/vector-clock-papel.pdf).

Esta biblioteca proporciona:

• Marca de tiempo de lamport
• Reloj de vector de asynchrone
• Synchrone Vector Reloj

Estas implementaciones siguen cuidadosamente el trabajo de investigación y todas las clases se prueban completamente (100% de cobertura).

Cada ejemplo presente en el documento se transcribe como una prueba de Phpunit.

Instalación

composer require dynamophp/vector-clock

Marca de tiempo de lamport

Uso

 <?php

$ lt1 = new LamportTimestamp ( 76 );
$ lt2 = new LamportTimestamp ( 59 );

assertEquals ( 76 , lt1-> getValue ());
assertEquals ( 59 , lt2-> getValue ());
assertTrue ( $ lt1 -> happenAfter ( $ lt2 )); // lt2 -> lt1
assertTrue ( $ lt2 -> happenBefore ( $ lt1 ));


$ lt1 -> applyLocalEvent ();
$ lt2 -> applyLocalEvent ();

assertEquals ( 77 , lt1-> getValue ());
assertEquals ( 60 , lt2-> getValue ());
assertTrue ( $ lt1 -> happenAfter ( $ lt2 )); // lt2 -> lt1
assertTrue ( $ lt2 -> happenBefore ( $ lt1 ));


$ lt1ToSend = clone $ lt1 -> applySendEvent ();
$ lt2 -> applyLocalEvent ();

assertEquals ( 78 , lt1-> getValue ());
assertEquals ( 78 , $ lt1ToSend -> getValue ());
assertEquals ( 61 , lt2-> getValue ());
assertTrue ( $ lt1 -> isIdenticalTo ( $ lt1ToSend )); // lt1 == lt1ToSend
assertFalse ( $ lt2 -> isIdenticalTo ( $ lt1ToSend )); // lt2 != lt1ToSend

$ lt2 -> applyReceiveEvent ( $ lt1ToSend );

assertEquals ( 78 , lt1-> getValue ());
assertEquals ( 79 , lt2-> getValue ());
assertTrue ( $ lt1 -> happenBefore ( $ lt2 )); // lt1 -> lt2
assertTrue ( $ lt2 -> happenAfter ( $ lt1 ));

En el caso de prueba: LamPorttimeStampScenariotest :: TestPaperFigure1a y LamPortTimestampScenariotest :: TestPaperFigure1B Puede ver el escenario completo del documento:

Reloj de vector de asynchrone

Uso

 <?php

// We create three clocks, one for each node in our system
$ clockNode1 = new AsyncVectorClock ( ' NODE-1 ' );
$ clockNode2 = new AsyncVectorClock ( ' NODE-2 ' );
$ clockNode3 = new AsyncVectorClock ( ' NODE-3 ' );

// Then, for each clock, we add the others nodes in the current vector 

$ clockNode1 -> addNode ( ' NODE-2 ' );
$ clockNode1 -> addNode ( ' NODE-3 ' );

$ clockNode2 -> addNode ( ' NODE-1 ' );
$ clockNode2 -> addNode ( ' NODE-3 ' );

$ clockNode3 -> addNode ( ' NODE-1 ' );
$ clockNode3 -> addNode ( ' NODE-2 ' );

// All clocks must look like [0, 0, 0]
// After the initialization part, we can play with our clocks

$ a = ( clone $ clockProcess1 )-> applySendEvent (); // [1, 0, 0]
$ l = ( clone $ clockProcess2 )-> applyLocalEvent (); // [0, 1, 0]
$ v = ( clone $ clockProcess3 )-> applyLocalEvent (); // [0, 0, 1]


$ b = ( clone $ a )-> applyLocalEvent (); // [2, 0, 0]
$ m = ( clone $ l )-> applyReceiveEvent ( $ a ); // [2, 2, 0]
$ w = ( clone $ v )-> applyLocalEvent (); // [0, 0, 3]

// And one more important thing, we can compare clocks

assertTrue ( $ l -> canBeComparedWith ( $ v )); 

assertTrue ( $ a -> isIdenticalTo ( $ a )); // a == a
assertTrue ( $ l -> isConcurrentWith ( $ v )); // l <-> v

assertTrue ( $ m -> happenAfter ( $ a )); // a -> m
assertTrue ( $ a -> happenBefore ( $ m )); // a -> m
assertTrue ( $ l -> happenBefore ( $ m )); // l -> m

En el caso de prueba: AsyncvectorScenariotest :: TestPaperFigure3 Puede ver el escenario completo del documento:

Synchrone Vector Reloj

Uso

 <?php

// We create three clocks, one for each node in our system
$ clockNode1 = new SyncVectorClock ( ' NODE-1 ' );
$ clockNode2 = new SyncVectorClock ( ' NODE-2 ' );
$ clockNode3 = new SyncVectorClock ( ' NODE-3 ' );

// Then, for each clock, we add the others nodes in the current vector 

$ clockNode1 -> addNode ( ' NODE-2 ' );
$ clockNode1 -> addNode ( ' NODE-3 ' );

$ clockNode2 -> addNode ( ' NODE-1 ' );
$ clockNode2 -> addNode ( ' NODE-3 ' );

$ clockNode3 -> addNode ( ' NODE-1 ' );
$ clockNode3 -> addNode ( ' NODE-2 ' );

// All clocks must look like [0, 0, 0] and are idle (i.e. not in communication with another node)
// After the initialization part, we can play with our clocks

assertTrue ( $ clockNode1 -> isIdle ());
assertTrue ( $ clockNode2 -> isIdle ());
assertTrue ( $ clockNode3 -> isIdle ());

$ a = ( clone $ clockNode1 )-> applyLocalEvent (); // [1, 0, 0]
$ t = ( clone $ clockNode3 )-> applyLocalEvent (); // [0, 0, 1]

// Then we want to make a synchrone communication between node1 and node2

$ b = clone $ a ; // [1, 0, 0]
$ l = clone $ clockNode2 ; // [0, 0, 0]

$ b -> applySendEvent ( $ l -> getNode ());
assertTrue ( $ b -> isCommunicating ());
assertEquals ( ' NODE-2 ' , $ b -> getCommunicatingNode ());

// $b sends its clock and is in a communicating state
// This means that, if you try to modify the clock you will get a ClockIsNotIdleException
// The only way for $b to become idle again is to receive a clock from NODE-2 (the current node is communicating with)
// As soon as $b receive a clock from NODE-2, it will merge it and go back to idle state and can be modified again

$ l -> applyReceiveEvent ( $ b ); // [2, 1, 0]
$ b -> applyReceiveEvent ( $ l ); // [2, 1, 0]

assertTrue ( $ b -> isIdle ());

// And one more important thing, we can compare clocks

assertTrue ( $ a -> canBeComparedWith ( $ t )); 

assertTrue ( $ a -> isIdenticalTo ( $ a )); // a == a
assertTrue ( $ l -> isIdenticalTo ( $ b )); // l == b

assertTrue ( $ a -> isConcurrentWith ( $ t )); // a <-> t

assertTrue ( $ l -> happenAfter ( $ a )); // a -> l
assertTrue ( $ a -> happenBefore ( $ b )); // a -> b
assertTrue ( $ a -> happenBefore ( $ l )); // a -> l

En el caso de prueba: SyncVectorScenariotest :: TestPaperFigure7 Puede ver el escenario completo del documento:

Cómo contribuir

Entorno

Puede iniciar el proyecto localmente, ya sea utilizando una instalación de PHP de la antigua moda o Docker.

Si usa Docker, hay un archivo Docker-Compose para usted en el directorio docker .

 cd docker && docker-compose up -d

Instalación de dependencias

Usando el compositor en tu dev env:

composer install

Calidad del código

Su código debe pasar a través de PhPCSFixer :

Arreglar src/

php vendor/bin/php-cs-fixer fix src --rules=@Symfony

Arreglar tests/

php vendor/bin/php-cs-fixer fix tests --rules=@Symfony

Y ser analizado por Phpstan

php vendor/bin/phpstan analyse src -c /app/phpstan.neon

Pruebas

El proyecto usa phpunit

Aquí está el comando para iniciar la suite de prueba

php vendor/phpunit/phpunit/phpunit --configuration phpunit.xml.dist tests

Nota: Necesita xdebug para la cobertura. Si está utilizando el Docker Env proporcionado en este proyecto, ya está instalado y configurado.

Convención de compromiso

Su mensaje de comisión debe seguir esta convención