Class: Quark::MdkDiscovery::Discovery

Inherits:
DatawireQuarkCore::QuarkObject show all
Extended by:
DatawireQuarkCore::Static
Defined in:
lib/mdk_discovery.rb

Overview

particular service (see the resolve method).

Constant Summary

Constants included from DatawireQuarkCore::Static

DatawireQuarkCore::Static::Unassigned

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from DatawireQuarkCore::Static

_lazy_statics, static, unlazy_statics

Methods inherited from DatawireQuarkCore::QuarkObject

#to_s

Constructor Details

#initialize(runtime) ⇒ Discovery

Construct a Discovery object. You must set the token before doing anything else; see the withToken() method.



1606
1607
1608
1609
1610
1611
1612
1613
1614
 
# File 'lib/mdk_discovery.rb', line 1606

def initialize(runtime)
    
    self.__init_fields__
    @logger.info("Discovery created!")
    (self).runtime = runtime
    (self)._fpfactory = ::DatawireQuarkCore.cast((runtime).dependencies.getService("failurepolicy_factory")) { ::Quark.mdk_discovery.FailurePolicyFactory }

    nil
end

Instance Attribute Details

#_fpfactory ⇒ Object

Returns the value of attribute _fpfactory.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def _fpfactory
  @_fpfactory
end

#_notificationCallback ⇒ Object

Returns the value of attribute _notificationCallback.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def _notificationCallback
  @_notificationCallback
end

#logger ⇒ Object

Returns the value of attribute logger.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def logger
  @logger
end

#mutex ⇒ Object

Returns the value of attribute mutex.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def mutex
  @mutex
end

#runtime ⇒ Object

Returns the value of attribute runtime.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def runtime
  @runtime
end

#services ⇒ Object

Returns the value of attribute services.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def services
  @services
end

#started ⇒ Object

Returns the value of attribute started.



1592
1593
1594
 
# File 'lib/mdk_discovery.rb', line 1592

def started
  @started
end

Instance Method Details

#__init_fields__ ⇒ Object 



1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
 
# File 'lib/mdk_discovery.rb', line 1905

def __init_fields__()
    
    self.logger = ::Quark.quark._getLogger("discovery")
    self.services = {}
    self.started = false
    self.mutex = ::DatawireQuarkCore::Lock.new()
    self.runtime = nil
    self._fpfactory = nil
    self._notificationCallback = nil

    nil
end

#_active(node) ⇒ Object 



1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
 
# File 'lib/mdk_discovery.rb', line 1812

def _active(node)
    
    self._lock()
    @logger.info(("adding ") + (node.toString()))
    cluster = self._getCluster((node).service, (node).environment)
    cluster.add(node)
    self._release()

    nil
end

#_expire(node) ⇒ Object 



1823
1824
1825
1826
1827
1828
1829
1830
1831
 
# File 'lib/mdk_discovery.rb', line 1823

def _expire(node)
    
    self._lock()
    @logger.info((("removing ") + (node.toString())) + (" from cluster"))
    self._getCluster((node).service, (node).environment).remove(node)
    self._release()

    nil
end

#_getClass ⇒ Object 



1843
1844
1845
1846
1847
1848
 
# File 'lib/mdk_discovery.rb', line 1843

def _getClass()
    
    return "mdk_discovery.Discovery"

    nil
end

#_getCluster(service, environment) ⇒ Object

Get the Cluster for a given service and environment.



1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
 
# File 'lib/mdk_discovery.rb', line 1698

def _getCluster(service, environment)
    
    clusters = self._getServices(environment)
    if (!((clusters).key?(service)))
        (clusters)[service] = (::Quark.mdk_discovery.Cluster.new((self)._fpfactory))
    end
    return (clusters)[service]

    nil
end

#_getField(name) ⇒ Object 



1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
 
# File 'lib/mdk_discovery.rb', line 1850

def _getField(name)
    
    if ((name) == ("logger"))
        return (self).logger
    end
    if ((name) == ("services"))
        return (self).services
    end
    if ((name) == ("started"))
        return (self).started
    end
    if ((name) == ("mutex"))
        return (self).mutex
    end
    if ((name) == ("runtime"))
        return (self).runtime
    end
    if ((name) == ("_fpfactory"))
        return (self)._fpfactory
    end
    if ((name) == ("_notificationCallback"))
        return (self)._notificationCallback
    end
    return nil

    nil
end

#_getServices(environment) ⇒ Object

Get the service to Cluster mapping for an Environment.



1685
1686
1687
1688
1689
1690
1691
1692
1693
 
# File 'lib/mdk_discovery.rb', line 1685

def _getServices(environment)
    
    if (!((@services).key?((environment).name)))
        (@services)[(environment).name] = ({})
    end
    return (@services)[(environment).name]

    nil
end

#_lock ⇒ Object

Lock.



1622
1623
1624
1625
1626
1627
 
# File 'lib/mdk_discovery.rb', line 1622

def _lock()
    
    @mutex.acquire()

    nil
end

#_release ⇒ Object 



1629
1630
1631
1632
1633
1634
 
# File 'lib/mdk_discovery.rb', line 1629

def _release()
    
    @mutex.release()

    nil
end

#_replace(service, environment, nodes) ⇒ Object 



1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
 
# File 'lib/mdk_discovery.rb', line 1791

def _replace(service, environment, nodes)
    
    self._lock()
    @logger.info(((("replacing all nodes for ") + (service)) + (" with ")) + ((nodes).to_s))
    cluster = self._getCluster(service, environment)
    currentNodes = ::Quark.quark.ListUtil.new().slice((cluster).nodes, 0, ((cluster).nodes).size)
    idx = 0
    while ((idx) < ((currentNodes).size)) do
        cluster.remove((currentNodes)[idx])
        idx = (idx) + (1)
    end
    idx = 0
    while ((idx) < ((nodes).size)) do
        cluster.add((nodes)[idx])
        idx = (idx) + (1)
    end
    self._release()

    nil
end

#_setField(name, value) ⇒ Object 



1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
 
# File 'lib/mdk_discovery.rb', line 1878

def _setField(name, value)
    
    if ((name) == ("logger"))
        (self).logger = value
    end
    if ((name) == ("services"))
        (self).services = ::DatawireQuarkCore.cast(value) { ::Hash }
    end
    if ((name) == ("started"))
        (self).started = ::DatawireQuarkCore.cast(value) { ::Object }
    end
    if ((name) == ("mutex"))
        (self).mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
    end
    if ((name) == ("runtime"))
        (self).runtime = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.MDKRuntime }
    end
    if ((name) == ("_fpfactory"))
        (self)._fpfactory = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.FailurePolicyFactory }
    end
    if ((name) == ("_notificationCallback"))
        (self)._notificationCallback = ::DatawireQuarkCore.cast(value) { ::Quark.quark.UnaryCallable }
    end

    nil
end

#failurePolicy(node) ⇒ Object

Get the FailurePolicy for a Node.



1724
1725
1726
1727
1728
1729
 
# File 'lib/mdk_discovery.rb', line 1724

def failurePolicy(node)
    
    return self._getCluster((node).service, (node).environment).failurePolicy(node)

    nil
end

#knownNodes(service, environment) ⇒ Object

Return the current known Nodes for a service in a particular Environment, if any.



1714
1715
1716
1717
1718
1719
 
# File 'lib/mdk_discovery.rb', line 1714

def knownNodes(service, environment)
    
    return (self._getCluster(service, environment)).nodes

    nil
end

#notify(callback) ⇒ Object

Register a callable that will be called with all incoming messages.



1836
1837
1838
1839
1840
1841
 
# File 'lib/mdk_discovery.rb', line 1836

def notify(callback)
    
    (self)._notificationCallback = callback

    nil
end

#onMessage(origin, message) ⇒ Object 



1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
 
# File 'lib/mdk_discovery.rb', line 1766

def onMessage(origin, message)
    
    if ((@_notificationCallback) != (nil))
        (@_notificationCallback).call(message)
    end
    klass = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
    if ((klass) == ("mdk_discovery.NodeActive"))
        active = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.NodeActive }
        self._active((active).node)
        return
    end
    if ((klass) == ("mdk_discovery.NodeExpired"))
        expire = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.NodeExpired }
        self._expire((expire).node)
        return
    end
    if ((klass) == ("mdk_discovery.ReplaceCluster"))
        replace = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.ReplaceCluster }
        self._replace((replace).cluster, (replace).environment, (replace).nodes)
        return
    end

    nil
end

#onStart(dispatcher) ⇒ Object

Start the uplink to the discovery service.



1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
 
# File 'lib/mdk_discovery.rb', line 1639

def onStart(dispatcher)
    
    self._lock()
    if (!(@started))
        @started = true
    end
    self._release()

    nil
end

#onStop ⇒ Object

Stop the uplink to the discovery service.



1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
 
# File 'lib/mdk_discovery.rb', line 1653

def onStop()
    
    self._lock()
    if (@started)
        @started = false
    end
    self._release()

    nil
end

#register(node) ⇒ Object

Register info about a service node with a discovery source of truth. You must usually start the uplink before this will do much; see start().



1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
 
# File 'lib/mdk_discovery.rb', line 1668

def register(node)
    
    registrar = nil
    if ((@runtime).dependencies.hasService("discovery_registrar"))
        registrar = ::DatawireQuarkCore.cast((@runtime).dependencies.getService("discovery_registrar")) { ::Quark.mdk_discovery.DiscoveryRegistrar }
    else
        raise ("Registration not supported as no Discovery Registrar was setup.")
    end
    ((self).runtime).dispatcher.tell(self, ::Quark.mdk_discovery.RegisterNode.new(node), registrar)
    return self

    nil
end

#resolve(service, version, environment) ⇒ Object

Resolve a service name into an available service node. You must usually start the uplink before this will do much; see start(). The returned Promise will end up with a Node as its value.



1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
 
# File 'lib/mdk_discovery.rb', line 1736

def resolve(service, version, environment)
    
    factory = ::Quark.mdk_runtime.promise.PromiseResolver.new((@runtime).dispatcher)
    self._lock()
    cluster = self._getCluster(service, environment)
    if (!(cluster.matchingVersionRegistered(version)))
        fallback = environment.getFallback()
        if ((fallback) != (nil))
            fallbackCluster = self._getCluster(service, fallback)
            if (!(fallbackCluster.matchingVersionRegistered(version)))
                fallbackCluster._addRequest(version, factory)
            else
                self._release()
                return self.resolve(service, version, fallback)
            end
        end
    end
    result = cluster.chooseVersion(version)
    if ((result) == (nil))
        cluster._addRequest(version, factory)
        self._release()
    else
        self._release()
        factory.resolve(result)
    end
    return (factory).promise

    nil
end