tiq 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e436fceef44012df5924defa9947216cac33a6703f222a738a0abc56f48c21b
+  data.tar.gz: b802bf48b8133fce415abc875069ee33eb2e3d362cc8e5043288c534d8caf856
+SHA512:
+  metadata.gz: 6bf88679ecc201e7a814724d8efa5888d8944515325c8d3ec087d4da95d23d8eae66745b941731ea7a195ac94a010f7785687773749de13ba2691baac6757f91
+  data.tar.gz: 80d673141cf5ea1d7cb213dc6ae0a4fa2c843f10fe4ec373ffa8ccf8c1e897c6d209520ee2ce23b7ad2f2ffad20edfcd8e20ab2455f88de434f4e316bb5eb38d

data/LICENSE.md

@@ -0,0 +1,29 @@
+# License
+
+    Copyright (C) 2022, Ecsypno <https://ecsypno.com/>
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification,
+    are permitted provided that the following conditions are met:
+
+        * Redistributions of source code must retain the above copyright notice,
+          this list of conditions and the following disclaimer.
+
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+
+        * Neither the name of the copyright holder nor the names of its contributors
+          may be used to endorse or promote products derived from this software
+          without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+    ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+    ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,178 @@
+# Tiq
+
+<table>
+    <tr>
+        <th>Version</th>
+        <td>0.0.1</td>
+    </tr>
+    <tr>
+        <th>Github page</th>
+        <td><a href="http://github.com/qadron/tiq">http://github.com/qadron/tiq</a></td>
+     </tr>
+    <tr>
+        <th>Code Documentation</th>
+        <td><a href="http://rubydoc.info/github/qadron/tiq/">http://rubydoc.info/github/qadron/tiq/</a></td>
+    </tr>
+    <tr>
+       <th>Author</th>
+       <td><a href="mailto:tasos.laskos@gmail.com">Tasos Laskos</a></td>
+    </tr>
+    <tr>
+        <th>Copyright</th>
+        <td>2025 <a href="https://ecsypno.com">Ecsypno</a></td>
+    </tr>
+    <tr>
+        <th>License</th>
+        <td><a href="file.LICENSE.html">3-clause BSD</a></td>
+    </tr>
+</table>
+
+## Synopsis
+
+Tiq is a simple and lightweight clustering solution protocol.
+
+This implementation is based on [Toq](https://github.com/qadron/toq) for Remote Procedure Call needs.
+
+## Concepts
+
+There are a few key concepts in `Tik`:
+
+### Node
+
+`Tik::Node` offers _Node_ representations, _server-side_ presences if you must.
+
+To start a _Node_, you need to create a class that inherits from `Tiq::Node`
+and instantiate it with a URL to bind to.
+
+```ruby
+cass MyNode < Tiq::Node
+end
+
+node = MyNode.new( url: "localhost:9999" )
+```
+
+### Cluster
+
+To create a _Cluster_, you need to create another _Node_ and specify any already
+existing one, as a _Cluster_ member, to be its _peer_.
+
+Any existing _Node_ would do.
+
+```ruby
+class MySecondNode < Tiq::Node
+end
+
+node_2 = MySecondNode.new( url: "localhost:9998", peer: 'localhost:9999' )
+```
+
+### Client
+
+`Tik::Client` offers a _Client_ to enable _Node_/User communications.
+
+```ruby
+client = MyClient.new( "localhost:9999" )
+
+# Issue calls on the server side and get us the responses.
+# Client will return `true`.
+p client.alive?
+# Client will return information about the Grid members.
+p client.peers
+# Client will return information about the Grid members.
+p client.info
+```
+
+### Channel
+
+Chanel _Nodes_ offer client-side access to the _Shared Data_; a Shared HashMap.
+
+This enables the establishment of channels via callbacks upon _Data_
+operations.
+
+```ruby
+class MyNode < Tiq::Node
+end
+
+class MySecondNode < Tiq::Node
+end
+
+class MyChannelNode < Tiq::Node
+end
+
+# Set up initial Node, the start of the cluster.
+node_1  = MyNode.new( url: "localhost:9999" )
+node_2  = MySecondNode.new( url: "localhost:9998", peer: 'localhost:9999' )
+channel = MyChannelNode.new( url: "localhost:9997", peer: 'localhost:9999' ).data
+sleep 1
+
+channel.on_set :my_signal do |value|
+    p "#{:on_set} - #{value}"
+end
+
+node_1.data.set :my_signal, 'tada!'
+sleep 1
+
+```
+
+### Add-ons
+
+_Node_ Add-ons are most commonly _Services_, and are are immensly easy to deploy
+and have up and running for
+every _Node_.
+
+```ruby
+class MyNode < Tiq::Node
+end
+
+class MyClient < Tiq::Client
+end
+
+# Set up initial Node.
+node_1 = MyNode.new( url: "localhost:9999" )
+
+# Add a service to the node, called :poll.
+Tiq::Addon::Attach node_1, :poll do |arguments = nil|
+    p "SERVICE: #{arguments}"
+end
+
+# Interact with the service via a Client.
+client_1 = MyClient.new( "localhost:9999" )
+Tiq::Addon  client_1, :poll, 'ping' do
+    puts "CLIENT: #{r}"
+end
+```
+
+### Data
+
+Data can be shared across _Nodes_ by means of broadcasting upon
+change - optional.
+
+```ruby
+class MyNode < Tiq::Node
+end
+
+class MySecondNode < Tiq::Node
+end
+
+# Set up initial Node, the start of the cluster.
+node_1 = MyNode.new( url: "localhost:9999" )
+node_2 = MySecondNode.new( url: "localhost:9998", peer: 'localhost:9999' )
+
+sleep 1
+
+node_2.data.on_set :my_signal do |value|
+    p "#{:on_set} - #{value}"
+end
+
+node_1.data.set :my_signal, 'tada!'
+sleep 1
+
+```
+
+## Installation
+
+    gem install tiq
+
+## License
+
+Tiq is provided under the 3-clause BSD license.
+See the `LICENSE` file for more information.

data/lib/tiq/channel.rb

@@ -0,0 +1,18 @@
+require 'msgpack'
+require 'toq'
+
+module Tiq
+class Channel
+
+    def initialize( url, options = {} )
+        host, port = url.split( ':' )
+        @client = Toq::Client.new( options.merge( host: host, port: port.to_i ) )
+    end
+
+    def method_missing( method, *args, &block )
+        @client.call( "data.#{method}", *args, &block )
+    end
+
+end
+
+end

data/lib/tiq/client.rb

@@ -0,0 +1,17 @@
+require 'msgpack'
+
+module Tiq
+class Client < Toq::Client
+
+    def initialize( url, options = {} )
+        host, port = url.split( ':' )
+        super( options.merge( host: host, port: port.to_i ) )
+    end
+
+    def method_missing( method, *args, &block )
+        call( "node.#{method}", *args, &block )
+    end
+
+end
+
+end

data/lib/tiq/node/addon.rb

@@ -0,0 +1,90 @@
+module Tiq
+
+    def self.Addon( node, shortname, *args, &block )
+        node.call_addon( shortname, *args, &block )
+    end
+
+    module Addon
+        def self.Attach( node, shortname = nil, &block )
+            node.attach_addon shortname, proc { |*arguments| block.call( *arguments ) }
+        end
+
+        def self.Dettach( node, shortname )
+            node.dettach_addon shortname
+        end
+
+        extend self
+    end
+
+class Node
+
+    # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    class Addon
+
+        attr_reader :node
+        attr_reader :data
+        attr_reader :options
+
+        def initialize( node, payload, options = {} )
+            @node    = node
+            @options = options
+            @data    = @node.data
+            @payload = payload
+        end
+
+        def call( *aguments, &block )
+            @payload.call( *aguments, &block )
+        end
+
+        # @return   [Server::node::Node]
+        #   Local node.
+        def node
+            node.instance_eval { @node }
+        end
+
+        # Defers a blocking operation in order to avoid blocking the main Reactor loop.
+        #
+        # The operation will be run in its own Thread - DO NOT block forever.
+        #
+        # Accepts either 2 parameters (an `operation` and a `callback` or an operation
+        # as a block.
+        #
+        # @param    [Proc]  operation
+        #   Operation to defer.
+        # @param    [Proc]  callback
+        #   Block to call with the results of the operation.
+        #
+        # @param    [Block]  block
+        #   Operation to defer.
+        def defer( operation = nil, callback = nil, &block )
+            Thread.new( *[operation, callback].compact, &block )
+        end
+
+        # Runs a block as soon as possible in the Reactor loop.
+        #
+        # @param    [Block] block
+        def run_asap( &block )
+            Raktr.global.next_tick( &block )
+        end
+
+        # @param    [Array]    list
+        #
+        # @return   [Raktr::Iterator]
+        #   Iterator for the provided array.
+        def iterator_for( list, max_concurrency = 10 )
+            Raktr.global.create_iterator( list, max_concurrency )
+        end
+
+        # Connects to a node by `url`
+        #
+        # @param    [String]    url
+        #
+        # @return   [Client::node]
+        def connect_to_node( url )
+            @node_connections ||= {}
+            @node_connections[url] ||= Tiq::Client.new( url )
+        end
+
+    end
+end
+end

data/lib/tiq/node/data.rb

@@ -0,0 +1,132 @@
+module Tiq
+class Node
+class Data
+
+    CONCURRENCY = 20
+
+    def initialize( node )
+        @hash = {}
+
+        @on_set_cb    = {}
+        @on_delete_cb = {}
+
+        @node = node
+    end
+
+    def update( data )
+        @hash.merge! data
+        nil
+    end
+
+    def get( k )
+        @hash[sanitize_key( k )]
+    end
+
+    def set( k, v, broadcast = true, &block )
+        k = sanitize_key( k )
+
+        if @hash[k] == v
+            block.call if block_given?
+            return
+        end
+
+        # p "#{@node} set #{k} #{v} 1"
+
+        @hash[k] = v
+        call_on_set( k, v )
+
+        if broadcast
+            each_peer do |peer, iterator|
+                peer.set( k, v, false ) { iterator.next }
+            end
+        end
+
+        block.call if block_given?
+        nil
+    end
+
+    def delete( k, broadcast = true, &block )
+        k = sanitize_key( k )
+
+        if !@hash.include? k
+            block.call if block_given?
+            return
+        end
+
+        @hash.delete( k )
+        call_on_delete( k )
+
+        if broadcast
+            each_peer do |peer, iterator|
+                peer.delete( k, false ) { iterator.next }
+            end
+        end
+
+        block.call if block_given?
+        nil
+    end
+
+    def on_set( k, &block )
+        # p "#{@node} on_set #{k} 0 #{block}"
+        (@on_set_cb[sanitize_key( k )] ||= []) << block
+        nil
+    end
+
+    def on_delete( k, &block )
+        (@on_delete_cb[sanitize_key( k )] ||= []) << block
+        nil
+    end
+
+    def to_h
+        @hash.dup
+    end
+
+    private
+
+    def call_on_set( k, v )
+        k = sanitize_key( k )
+
+        # p "#{@node} call_on_set #{k} 2"
+        # p @on_set_cb
+        # p "--- PEERS #{@node.peers}"
+
+        if @on_set_cb[k]
+            @on_set_cb[k].each do |cb|
+                cb.call k, v
+            end
+        end
+
+        nil
+    end
+
+    def call_on_delete( k )
+        k = sanitize_key( k )
+        return if !@on_delete_cb[k]
+
+        @on_delete_cb[k].each do |cb|
+            cb.call k
+        end
+
+        nil
+    end
+
+    def each_peer( &block )
+        each  = proc do |url, iterator|
+            block.call connect_to_peer( url ), iterator
+        end
+        @node.reactor.create_iterator( @node.peers, CONCURRENCY ).each( each )
+    end
+
+    def connect_to_peer( url, options = {} )
+        @rpc_clients      ||= {}
+        @rpc_clients[url] ||= Tiq::Channel.new( url, options )
+    end
+
+    def sanitize_key( k )
+        k.to_s
+    end
+
+end
+
+end
+end

data/lib/tiq/node.rb

@@ -0,0 +1,300 @@
+require 'set'
+require_relative 'node/data'
+require_relative 'channel'
+require_relative 'client'
+
+module Tiq
+
+class Node
+
+    INTERVAL_PING = 5
+
+    attr_reader :data
+    attr_reader :services
+    attr_reader :reactor
+
+    # Initializes the node by:
+    #
+    #   * Adding the peer (if the user has supplied one) to the peer list.
+    #   * Getting the peer's peer list and appending them to its own.
+    #   * Announces itself to the peer and instructs it to propagate our URL
+    #     to the others.
+    #
+    # @param    [Cuboid::Options]    options
+    def initialize( options )
+        @options = options
+        @url     = @options[:url]
+
+        $stdout.puts 'Initializing node...'
+
+        @dead_nodes = Set.new
+        @peers      = Set.new
+        @addons   = {}
+        @nodes_info_cache = []
+
+        host, port = @url.split( ':' )
+        options[:host] ||= host || 'localhost'
+        options[:port] ||= port || 9999
+
+        @server  = Toq::Server.new( host: options[:host], port: options[:port] )
+        @reactor = @server.reactor
+        @server.add_async_check do |method|
+            # methods that expect a block are async
+            method.parameters.flatten.include? :block
+        end
+        @server.add_handler( 'node', self )
+
+        @reactor.run_in_thread if !@reactor.running?
+
+        @data = Data.new( self )
+        @server.add_handler( 'data', @data )
+
+        @reactor.on_error do |_, e|
+            $stderr.puts "Reactor: #{e}"
+
+            e.backtrace.each do |l|
+                $stderr.puts "Reactor: #{l}"
+            end
+        end
+
+        @reactor.at_interval( @options[:ping_interval] || INTERVAL_PING ) do
+            ping
+            check_for_comebacks
+        end
+
+        if( peer = @options[:peer] )
+            # Grab the peer's peers.
+            connect_to_peer( peer ).peers do |grid_peers|
+                if grid_peers.rpc_exception?
+                    $stdout.puts "Peer seems dead: #{peer}"
+                    $stderr.puts "Reactor: #{grid_peers}"
+
+                    if grid_peers.backtrace
+                        grid_peers.backtrace.each do |l|
+                            $stderr.puts "Reactor: #{l}"
+                        end
+                    end
+
+                    add_dead_peer( peer )
+                    next
+                end
+
+                begin
+                    grid_peers << peer
+                    grid_peers.each { |url| add_peer url }
+
+                    announce @url
+                rescue => e
+                    p e
+                end
+            end
+        end
+
+        $stdout.puts 'Node ready.'
+
+        log_updated_peers
+
+        run
+    end
+
+    def attach_addon( name, service, options = {} )
+        @addons[name.to_s] = Addon.new( self, service, options )
+        nil
+    end
+
+    def call_addon( name, *arguments )
+        @addons[name.to_s].call( *arguments )
+    end
+
+    def addons
+        @addons.keys
+    end
+
+    def dettach_addon( name )
+        @addons.delete name
+    end
+
+    # @return   [Boolean]
+    #   `true` if grid member, `false` otherwise.
+    def grid_member?
+        @peers.any?
+    end
+
+    def unplug
+        @server.create_iterator( @peers, 20 ).each do |peer, iterator|
+            connect_to_peer( peer ).remove_peer( @url ) { iterator.next }
+        end
+
+        @peers.clear
+        @dead_nodes.clear
+
+        nil
+    end
+
+    # Adds a peer to the peer list.
+    #
+    # @param    [String]    node_url
+    #   URL of a peering node.
+    def add_peer( node_url )
+        $stdout.puts "Adding peer: #{node_url}"
+        @peers << node_url
+
+        connect_to_peer( node_url ){ update_data( @data.to_h ) }
+
+        log_updated_peers
+        true
+    end
+
+    def update_data( data )
+        @data.update( data )
+        nil
+    end
+
+    def remove_peer( url )
+        @peers.delete url
+        @dead_nodes.delete url
+        nil
+    end
+
+    # @return   [Array]
+    #   Peer/node/peer URLs.
+    def peers
+        @peers.to_a
+    end
+
+    def peers_with_info( &block )
+        fail 'This method requires a block!' if !block_given?
+
+        @peers_cmp = ''
+
+        if @nodes_info_cache.empty? || @peers_cmp != peers.to_s
+            @peers_cmp = peers.to_s
+
+            each = proc do |peer, iter|
+                connect_to_peer( peer ).info do |info|
+                    if info.rpc_exception?
+                        $stdout.puts "Peer seems dead: #{peer}"
+                        add_dead_peer( peer )
+                        log_updated_peers
+
+                        iter.return( nil )
+                    else
+                        iter.return( info )
+                    end
+                end
+            end
+
+            after = proc do |nodes|
+                @nodes_info_cache = nodes.compact
+                block.call( @nodes_info_cache )
+            end
+
+            @reactor.create_iterator( peers ).map( each, after )
+        else
+            block.call( @nodes_info_cache )
+        end
+    end
+
+    # @return    [Hash]
+    #
+    #   * `url` -- This node's URL.
+    #   * `name` -- Nickname
+    #   * `peers` -- Array of peers.
+    def info
+        {
+          'url'               => @url,
+          'name'              => @options[:name],
+          'peers'             => self.peers,
+          'unreachable_peers' => @dead_nodes.to_a
+        }
+    end
+
+    def alive?
+        true
+    end
+
+    def run
+        $stdout.puts 'Running'
+        @server.start
+    rescue => e
+        $stderr.puts e
+        $stderr.puts "Could not start server"
+        e.backtrace.each do |l|
+            $stderr.puts l
+        end
+
+        exit 1
+    end
+
+    def shutdown
+        Thread.new do
+            $stdout.puts 'Shutting down...'
+            @reactor.stop
+        end
+    end
+
+    private
+
+    def add_dead_peer( url )
+        remove_peer( url )
+        @dead_nodes << url
+    end
+
+    def log_updated_peers
+        $stdout.puts 'Updated peers:'
+
+        if !peers.empty?
+            peers.each { |node| $stdout.puts( '---- ' + node ) }
+        else
+            $stdout.puts '<empty>'
+        end
+    end
+
+    def ping
+        peers.each do |peer|
+            connect_to_peer( peer ).alive? do |res|
+                next if !res.rpc_exception?
+                add_dead_peer( peer )
+                $stdout.puts "Found dead peer: #{peer} "
+            end
+        end
+    end
+
+    def check_for_comebacks
+        @dead_nodes.dup.each do |url|
+            peer = connect_to_peer( url )
+            peer.alive? do |res|
+                next if res.rpc_exception?
+
+                $stdout.puts "Peer came back to life: #{url}"
+                ([@url] | peers).each do |node|
+                    peer.add_peer( node ){}
+                end
+
+                add_peer( url )
+                @dead_nodes.delete url
+            end
+        end
+    end
+
+    # Announces the node to the ones in the peer list
+    #
+    # @param    [String]    node
+    #   URL
+    def announce( node )
+        $stdout.puts "Announcing: #{node}"
+
+        peers.each do |peer|
+            $stdout.puts "---- to: #{peer}"
+            connect_to_peer( peer ).add_peer( node ) do |res|
+                add_dead_peer( peer ) if res.rpc_exception?
+            end
+        end
+    end
+
+    def connect_to_peer( url, options = {} )
+        @rpc_clients      ||= {}
+        @rpc_clients[url] ||= Tiq::Client.new( url, options )
+    end
+end
+end

data/lib/tiq.rb

@@ -0,0 +1,8 @@
+require 'msgpack'
+require_relative 'tiq/node'
+require_relative 'tiq/client'
+require_relative 'tiq/channel'
+
+module Tiq
+    VERSION = '0.1'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require_relative '../lib/tiq'
+
+RSpec.configure do |config|
+    config.color = true
+    config.add_formatter :documentation
+
+    # config.filter_run_including focus: true
+end

data/spec/tiq/channel_spec.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/tiq/client_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Tiq::Client do
+
+end

data/spec/tiq/node/addon_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'Tiq::Node::Addon' do
+    let( :node ) { @node ||= Tiq::Node.new( url: 'localhost:9999' ) }
+    let( :peer ) { @peer ||= Tiq::Node.new( url: 'localhost:9998', peer: 'localhost:9999' ) }
+
+    before( :each ) do
+        node
+        peer
+        sleep 0.1
+    end
+
+    after( :each ) do
+        @peer.shutdown
+        @peer = nil
+        @node.shutdown
+        @node = nil
+        sleep 1
+    end
+
+    it 'attaches and calls an addon' do
+        node.attach_addon( 'echo', 'Tiq::Service::Echo' )
+        result = node.call_addon( 'echo', 'hello' )
+        expect( result ).to eq 'hello'
+    end
+
+    it 'lists addons' do
+        node.attach_addon( 'echo', 'Tiq::Service::Echo' )
+        expect( node.addons ).to include 'echo'
+    end
+end

data/spec/tiq/node/data_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Tiq::Node::Data do
+    let( :node ) { @node ||= Tiq::Node.new( url: 'localhost:9999' ) }
+    let( :peer ) { @peer ||= Tiq::Node.new( url: 'localhost:9998', peer: 'localhost:9999' ) }
+
+    before( :each ) do
+        node
+        peer
+        sleep 0.1
+    end
+
+    after( :each ) do
+        @peer.shutdown
+        @peer = nil
+        @node.shutdown
+        @node = nil
+        sleep 1
+    end
+
+    it 'sets and gets data locally' do
+        node.data.set( 'key1', 'value1' )
+        expect( node.data.get( 'key1' ) ).to eq 'value1'
+    end
+
+    it 'propagates data to peers' do
+        node.data.set( 'key2', 'value2' )
+        sleep 1
+        expect( peer.data.get( 'key2' ) ).to eq 'value2'
+    end
+
+    it 'does not propagate data when broadcast is false' do
+        node.data.set( 'key3', 'value3', false )
+        sleep 0.1
+        expect( peer.data.get( 'key3' ) ).to be_nil
+    end
+
+    it 'calls on_set callbacks' do
+        called = false
+        peer.data.on_set( 'key4' ) { |k, v| called = (k == 'key4' && v == 'value4') }
+        node.data.set( 'key4', 'value4' )
+        sleep 1
+        expect( called ).to be true
+    end
+
+    it 'calls on_delete callbacks' do
+        called = false
+        peer.data.set( 'key5', 'value5' )
+        sleep 1
+        peer.data.on_delete( 'key5' ) { |k| called = (k == 'key5') }
+        node.data.delete( 'key5' )
+        sleep 1
+        expect( called ).to be true
+    end
+
+    it 'does not call on_set callback when value is unchanged' do
+        count = 0
+        peer.data.on_set( 'key6' ) { count += 1 }
+        node.data.set( 'key6', 'value6' )
+        node.data
+    end
+end

data/spec/tiq/node_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Tiq::Node do
+    let( :node ) { @node ||= Tiq::Node.new( url: 'localhost:9999' ) }
+    let( :peer ) { @peer ||= Tiq::Node.new( url: 'localhost:9998', peer: 'localhost:9999' ) }
+
+    before( :each ) do
+        node
+        peer
+        sleep 0.1
+    end
+
+    after( :each ) do
+        @peer.shutdown
+        @peer = nil
+        @node.shutdown
+        @node = nil
+        sleep 1
+    end
+
+    it 'sets and gets data locally' do
+        node.data.set( 'key1', 'value1' )
+        expect( node.data.get( 'key1' ) ).to eq 'value1'
+    end
+
+    it 'propagates data to peers' do
+        node.data.set( 'key2', 'value2' )
+        sleep 1
+        expect( peer.data.get( 'key2' ) ).to eq 'value2'
+    end
+
+    it 'does not propagate data when broadcast is false' do
+        node.data.set( 'key3', 'value3', false )
+        sleep 0.1
+        expect( peer.data.get( 'key3' ) ).to be_nil
+    end
+
+    it 'calls on_set callbacks' do
+        called = false
+        peer.data.on_set( 'key4' ) { |k, v| called = (k == 'key4' && v == 'value4') }
+        node.data.set( 'key4', 'value4' )
+        sleep 1
+        expect( called ).to be true
+    end
+
+    it 'calls on_delete callbacks' do
+        called = false
+        peer.data.set( 'key5', 'value5' )
+        sleep 1
+        peer.data.on_delete( 'key5' ) { |k| called = (k == 'key5') }
+        node.data.delete( 'key5' )
+        sleep 1
+        expect( called ).to be true
+    end
+
+    it 'does not call on_set callback when value is unchanged' do
+        count = 0
+        peer.data.on_set( 'key6' ) { count += 1 }
+        node.data.set( 'key6', 'value6' )
+        node.data.set( 'key6', 'value6' )
+    end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: tiq
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Tasos Laskos
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: toq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email: tasos.laskos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/tiq.rb
+- lib/tiq/channel.rb
+- lib/tiq/client.rb
+- lib/tiq/node.rb
+- lib/tiq/node/addon.rb
+- lib/tiq/node/data.rb
+- spec/spec_helper.rb
+- spec/tiq/channel_spec.rb
+- spec/tiq/client_spec.rb
+- spec/tiq/node/addon_spec.rb
+- spec/tiq/node/data_spec.rb
+- spec/tiq/node_spec.rb
+homepage: https://github.com/qadron/tiq
+licenses:
+- BSD 3-Clause
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: Simple RPC protocol.
+test_files:
+- spec/tiq/client_spec.rb
+- spec/tiq/node_spec.rb
+- spec/tiq/channel_spec.rb
+- spec/tiq/node/data_spec.rb
+- spec/tiq/node/addon_spec.rb
+- spec/spec_helper.rb