datawire_mdk 2.0.22 → 2.0.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/lib/mdk_protocol.rb CHANGED
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_protocol; MdkProtocol; end
@@ -942,17 +942,18 @@ def self.OpenCloseSubscriber; OpenCloseSubscriber; end
942
942
  # Handle Open and Close messages.
943
943
 
944
944
  class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
945
- attr_accessor :_dispatcher, :_wsclient
945
+ attr_accessor :_dispatcher, :_wsclient, :_node_id
946
946
  extend ::DatawireQuarkCore::Static
947
947
 
948
948
  static mdk_protocol_OpenCloseSubscriber_ref: -> { nil }
949
949
 
950
950
 
951
951
 
952
- def initialize(client)
952
+ def initialize(client, node_id)
953
953
 
954
954
  self.__init_fields__
955
955
  (self)._wsclient = client
956
+ (self)._node_id = node_id
956
957
  (self)._wsclient.subscribe(self)
957
958
 
958
959
  nil
@@ -1000,7 +1001,9 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
1000
1001
 
1001
1002
  def onWSConnected(websocket)
1002
1003
 
1003
- (self)._dispatcher.tell(self, ::Quark.mdk_protocol.Open.new().encode(), websocket)
1004
+ open = ::Quark.mdk_protocol.Open.new()
1005
+ ((open).properties)["datawire_nodeId"] = ((self)._node_id)
1006
+ (self)._dispatcher.tell(self, open.encode(), websocket)
1004
1007
 
1005
1008
  nil
1006
1009
  end
@@ -1041,6 +1044,9 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
1041
1044
  if ((name) == ("_wsclient"))
1042
1045
  return (self)._wsclient
1043
1046
  end
1047
+ if ((name) == ("_node_id"))
1048
+ return (self)._node_id
1049
+ end
1044
1050
  return nil
1045
1051
 
1046
1052
  nil
@@ -1054,6 +1060,9 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
1054
1060
  if ((name) == ("_wsclient"))
1055
1061
  (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
1056
1062
  end
1063
+ if ((name) == ("_node_id"))
1064
+ (self)._node_id = ::DatawireQuarkCore.cast(value) { ::String }
1065
+ end
1057
1066
 
1058
1067
  nil
1059
1068
  end
@@ -1062,6 +1071,7 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
1062
1071
 
1063
1072
  self._dispatcher = nil
1064
1073
  self._wsclient = nil
1074
+ self._node_id = nil
1065
1075
 
1066
1076
  nil
1067
1077
  end
@@ -1536,6 +1546,356 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
1536
1546
  end
1537
1547
  WSClient.unlazy_statics
1538
1548
 
1549
+ def self.AckablePayload; AckablePayload; end
1550
+ ##
1551
+ # The payload for an ackable event.
1552
+
1553
+ class AckablePayload < ::DatawireQuarkCore::QuarkObject
1554
+ extend ::DatawireQuarkCore::Static
1555
+
1556
+ static mdk_protocol_AckablePayload_ref: -> { nil }
1557
+
1558
+
1559
+
1560
+ def initialize()
1561
+ self.__init_fields__
1562
+
1563
+ nil
1564
+ end
1565
+
1566
+
1567
+
1568
+
1569
+ ##
1570
+ # When did this happen? Milliseconds since Unix epoch.
1571
+
1572
+ def getTimestamp()
1573
+ raise NotImplementedError, '`AckablePayload.getTimestamp` is an abstract method'
1574
+
1575
+ nil
1576
+ end
1577
+
1578
+ def __init_fields__()
1579
+
1580
+
1581
+ nil
1582
+ end
1583
+
1584
+
1585
+ end
1586
+ AckablePayload.unlazy_statics
1587
+
1588
+ def self.AckableEvent; AckableEvent; end
1589
+ ##
1590
+ # An event that can be acknowledged.
1591
+
1592
+ class AckableEvent < ::DatawireQuarkCore::QuarkObject
1593
+ attr_accessor :json_type, :sequence, :sync, :payload
1594
+ extend ::DatawireQuarkCore::Static
1595
+
1596
+ static mdk_protocol_AckableEvent_ref: -> { nil }
1597
+
1598
+
1599
+
1600
+ def initialize(json_type, payload, sequence)
1601
+
1602
+ self.__init_fields__
1603
+ (self).json_type = json_type
1604
+ (self).payload = payload
1605
+ (self).sequence = sequence
1606
+
1607
+ nil
1608
+ end
1609
+
1610
+
1611
+
1612
+
1613
+ def getTimestamp()
1614
+
1615
+ return @payload.getTimestamp()
1616
+
1617
+ nil
1618
+ end
1619
+
1620
+ def encode()
1621
+
1622
+ clazz = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass((self).payload))
1623
+ json = ::Quark.quark.toJSON((self).payload, clazz)
1624
+ (json).setObjectItem(("type"), (::DatawireQuarkCore::JSONObject.new.setString((self).json_type)))
1625
+ (json).setObjectItem(("sequence"), (::DatawireQuarkCore::JSONObject.new.setNumber((self).sequence)))
1626
+ (json).setObjectItem(("sync"), (::DatawireQuarkCore::JSONObject.new.setNumber((self).sync)))
1627
+ encoded = json.toString()
1628
+ return encoded
1629
+
1630
+ nil
1631
+ end
1632
+
1633
+ def _getClass()
1634
+
1635
+ return "mdk_protocol.AckableEvent"
1636
+
1637
+ nil
1638
+ end
1639
+
1640
+ def _getField(name)
1641
+
1642
+ if ((name) == ("json_type"))
1643
+ return (self).json_type
1644
+ end
1645
+ if ((name) == ("sequence"))
1646
+ return (self).sequence
1647
+ end
1648
+ if ((name) == ("sync"))
1649
+ return (self).sync
1650
+ end
1651
+ if ((name) == ("payload"))
1652
+ return (self).payload
1653
+ end
1654
+ return nil
1655
+
1656
+ nil
1657
+ end
1658
+
1659
+ def _setField(name, value)
1660
+
1661
+ if ((name) == ("json_type"))
1662
+ (self).json_type = ::DatawireQuarkCore.cast(value) { ::String }
1663
+ end
1664
+ if ((name) == ("sequence"))
1665
+ (self).sequence = ::DatawireQuarkCore.cast(value) { ::Integer }
1666
+ end
1667
+ if ((name) == ("sync"))
1668
+ (self).sync = ::DatawireQuarkCore.cast(value) { ::Integer }
1669
+ end
1670
+ if ((name) == ("payload"))
1671
+ (self).payload = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.AckablePayload }
1672
+ end
1673
+
1674
+ nil
1675
+ end
1676
+
1677
+ def __init_fields__()
1678
+
1679
+ self.json_type = nil
1680
+ self.sequence = nil
1681
+ self.sync = 0
1682
+ self.payload = nil
1683
+
1684
+ nil
1685
+ end
1686
+
1687
+
1688
+ end
1689
+ AckableEvent.unlazy_statics
1690
+
1691
+ def self.SendWithAcks; SendWithAcks; end
1692
+ ##
1693
+ # Utility class for sending messages with a protocol that sends back acks.
1694
+ #
1695
+
1696
+ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
1697
+ attr_accessor :_syncRequestPeriod, :_syncInFlightMax, :_buffered, :_inFlight, :_added, :_sent, :_failedSends, :_recorded, :_lastSyncTime, :_myLog
1698
+ extend ::DatawireQuarkCore::Static
1699
+
1700
+ static quark_List_mdk_protocol_AckableEvent__ref: -> { nil }
1701
+ static mdk_protocol_SendWithAcks_ref: -> { nil }
1702
+
1703
+
1704
+
1705
+ def initialize()
1706
+ self.__init_fields__
1707
+
1708
+ nil
1709
+ end
1710
+
1711
+
1712
+
1713
+
1714
+ def _debug(message)
1715
+
1716
+ s = (((("[") + (((@_buffered).size).to_s)) + (" buf, ")) + (((@_inFlight).size).to_s)) + (" inf] ")
1717
+ @_myLog.debug((s) + (message))
1718
+
1719
+ nil
1720
+ end
1721
+
1722
+ ##
1723
+ # Call when (re)connected to other side.
1724
+
1725
+ def onConnected(origin, dispatcher, sock)
1726
+
1727
+ while (((@_buffered).size) > (0)) do
1728
+ debugSuffix = ""
1729
+ evt = (@_buffered).delete_at(0)
1730
+ (@_inFlight) << (evt)
1731
+ if (((evt.getTimestamp()) > ((@_lastSyncTime) + (@_syncRequestPeriod))) || (((@_inFlight).size) == (@_syncInFlightMax)))
1732
+ (evt).sync = 1
1733
+ @_lastSyncTime = evt.getTimestamp()
1734
+ debugSuffix = " with sync set"
1735
+ end
1736
+ dispatcher.tell(origin, evt.encode(), sock)
1737
+ (evt).sync = 0
1738
+ @_sent = (@_sent) + ((1))
1739
+ self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + ((sock).to_s))
1740
+ end
1741
+
1742
+ nil
1743
+ end
1744
+
1745
+ ##
1746
+ # Call to send buffered messages.
1747
+
1748
+ def onPump(origin, dispatcher, sock)
1749
+
1750
+ while (((@_buffered).size) > (0)) do
1751
+ debugSuffix = ""
1752
+ evt = (@_buffered).delete_at(0)
1753
+ (@_inFlight) << (evt)
1754
+ if (((evt.getTimestamp()) > ((@_lastSyncTime) + (@_syncRequestPeriod))) || (((@_inFlight).size) == (@_syncInFlightMax)))
1755
+ (evt).sync = 1
1756
+ @_lastSyncTime = evt.getTimestamp()
1757
+ debugSuffix = " with sync set"
1758
+ end
1759
+ dispatcher.tell(origin, evt.encode(), sock)
1760
+ (evt).sync = 0
1761
+ @_sent = (@_sent) + ((1))
1762
+ self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + ((sock).to_s))
1763
+ end
1764
+
1765
+ nil
1766
+ end
1767
+
1768
+ ##
1769
+ # Called when receiving acknowledgement from other side.
1770
+
1771
+ def onAck(sequence)
1772
+
1773
+ while (((@_inFlight).size) > (0)) do
1774
+ if ((((@_inFlight)[0]).sequence) <= (sequence))
1775
+ evt = (@_inFlight).delete_at(0)
1776
+ @_recorded = (@_recorded) + ((1))
1777
+ self._debug(((("ack #") + ((sequence).to_s)) + (", discarding #")) + (((evt).sequence).to_s))
1778
+ else
1779
+ break
1780
+ end
1781
+ end
1782
+
1783
+ nil
1784
+ end
1785
+
1786
+ ##
1787
+ # Send an event.
1788
+
1789
+ def send(json_type, event)
1790
+
1791
+ wrapper = ::Quark.mdk_protocol.AckableEvent.new(json_type, event, @_added)
1792
+ @_added = (@_added) + ((1))
1793
+ (@_buffered) << (wrapper)
1794
+ self._debug(("logged #") + (((wrapper).sequence).to_s))
1795
+
1796
+ nil
1797
+ end
1798
+
1799
+ def _getClass()
1800
+
1801
+ return "mdk_protocol.SendWithAcks"
1802
+
1803
+ nil
1804
+ end
1805
+
1806
+ def _getField(name)
1807
+
1808
+ if ((name) == ("_syncRequestPeriod"))
1809
+ return (self)._syncRequestPeriod
1810
+ end
1811
+ if ((name) == ("_syncInFlightMax"))
1812
+ return (self)._syncInFlightMax
1813
+ end
1814
+ if ((name) == ("_buffered"))
1815
+ return (self)._buffered
1816
+ end
1817
+ if ((name) == ("_inFlight"))
1818
+ return (self)._inFlight
1819
+ end
1820
+ if ((name) == ("_added"))
1821
+ return (self)._added
1822
+ end
1823
+ if ((name) == ("_sent"))
1824
+ return (self)._sent
1825
+ end
1826
+ if ((name) == ("_failedSends"))
1827
+ return (self)._failedSends
1828
+ end
1829
+ if ((name) == ("_recorded"))
1830
+ return (self)._recorded
1831
+ end
1832
+ if ((name) == ("_lastSyncTime"))
1833
+ return (self)._lastSyncTime
1834
+ end
1835
+ if ((name) == ("_myLog"))
1836
+ return (self)._myLog
1837
+ end
1838
+ return nil
1839
+
1840
+ nil
1841
+ end
1842
+
1843
+ def _setField(name, value)
1844
+
1845
+ if ((name) == ("_syncRequestPeriod"))
1846
+ (self)._syncRequestPeriod = ::DatawireQuarkCore.cast(value) { ::Integer }
1847
+ end
1848
+ if ((name) == ("_syncInFlightMax"))
1849
+ (self)._syncInFlightMax = ::DatawireQuarkCore.cast(value) { ::Integer }
1850
+ end
1851
+ if ((name) == ("_buffered"))
1852
+ (self)._buffered = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
1853
+ end
1854
+ if ((name) == ("_inFlight"))
1855
+ (self)._inFlight = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
1856
+ end
1857
+ if ((name) == ("_added"))
1858
+ (self)._added = ::DatawireQuarkCore.cast(value) { ::Integer }
1859
+ end
1860
+ if ((name) == ("_sent"))
1861
+ (self)._sent = ::DatawireQuarkCore.cast(value) { ::Integer }
1862
+ end
1863
+ if ((name) == ("_failedSends"))
1864
+ (self)._failedSends = ::DatawireQuarkCore.cast(value) { ::Integer }
1865
+ end
1866
+ if ((name) == ("_recorded"))
1867
+ (self)._recorded = ::DatawireQuarkCore.cast(value) { ::Integer }
1868
+ end
1869
+ if ((name) == ("_lastSyncTime"))
1870
+ (self)._lastSyncTime = ::DatawireQuarkCore.cast(value) { ::Integer }
1871
+ end
1872
+ if ((name) == ("_myLog"))
1873
+ (self)._myLog = value
1874
+ end
1875
+
1876
+ nil
1877
+ end
1878
+
1879
+ def __init_fields__()
1880
+
1881
+ self._syncRequestPeriod = 5000
1882
+ self._syncInFlightMax = 50
1883
+ self._buffered = ::DatawireQuarkCore::List.new([])
1884
+ self._inFlight = ::DatawireQuarkCore::List.new([])
1885
+ self._added = 0
1886
+ self._sent = 0
1887
+ self._failedSends = 0
1888
+ self._recorded = 0
1889
+ self._lastSyncTime = 0
1890
+ self._myLog = ::Quark.quark._getLogger("SendWithAcks")
1891
+
1892
+ nil
1893
+ end
1894
+
1895
+
1896
+ end
1897
+ SendWithAcks.unlazy_statics
1898
+
1539
1899
 
1540
1900
  require_relative 'datawire_mdk_md' # 0 () ()
1541
1901
 
data/lib/mdk_rtp.rb CHANGED
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_rtp; MdkRtp; end
@@ -29,6 +29,8 @@ def self.getRTPParser()
29
29
  parser.register("logack", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogAck"))
30
30
  parser.register("mdk_tracing.protocol.LogAckEvent", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogAck"))
31
31
  parser.register("subscribe", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.Subscribe"))
32
+ parser.register("interaction_event", ::Quark.quark.reflect.QuarkClass.get("mdk_metrics.InteractionEvent"))
33
+ parser.register("interaction_ack", ::Quark.quark.reflect.QuarkClass.get("mdk_metrics.InteractionAck"))
32
34
  return parser
33
35
 
34
36
 
data/lib/mdk_runtime.rb CHANGED
@@ -1,4 +1,4 @@
1
- # Quark 1.0.452 run at 2016-10-24 14:33:24.783025
1
+ # Quark 1.0.452 run at 2016-10-26 12:53:21.596699
2
2
  module Quark
3
3
  require "quark"
4
4
  def self.mdk_runtime; MdkRuntime; end
@@ -1122,6 +1122,21 @@ class FakeWSActor < ::DatawireQuarkCore::QuarkObject
1122
1122
  nil
1123
1123
  end
1124
1124
 
1125
+ ##
1126
+ # Skip over any logged messages for purposes of expectTextMessage().
1127
+
1128
+ def swallowLogMessages()
1129
+
1130
+ if (!(@resolved))
1131
+ ::Quark.quark.concurrent.Context.runtime().fail("not connected yet")
1132
+ end
1133
+ while (((@expectIdx) < (((self).sent).size)) && ((((((self).sent)[@expectIdx]).index("mdk_tracing.protocol.LogEvent") or -1)) != (-(1)))) do
1134
+ @expectIdx = (@expectIdx) + (1)
1135
+ end
1136
+
1137
+ nil
1138
+ end
1139
+
1125
1140
  ##
1126
1141
  # Check that a message has been sent via this actor.
1127
1142
  #
@@ -1748,7 +1763,7 @@ def self.FakeTime; FakeTime; end
1748
1763
  # Testing fake.
1749
1764
 
1750
1765
  class FakeTime < ::DatawireQuarkCore::QuarkObject
1751
- attr_accessor :_now, :_scheduled, :dispatcher
1766
+ attr_accessor :_now, :_scheduled, :dispatcher, :_counter
1752
1767
  extend ::DatawireQuarkCore::Static
1753
1768
 
1754
1769
  static quark_List_quark_long__ref: -> { nil }
@@ -1776,7 +1791,8 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
1776
1791
  def onMessage(origin, msg)
1777
1792
 
1778
1793
  sched = ::DatawireQuarkCore.cast(msg) { ::Quark.mdk_runtime.Schedule }
1779
- (@_scheduled)[((::DatawireQuarkCore::List.new((@_scheduled).keys)).size)] = (::Quark.mdk_runtime._FakeTimeRequest.new(origin, (sched).event, ((self)._now) + ((sched).seconds)))
1794
+ (self)._counter = ((self)._counter) + (1)
1795
+ (@_scheduled)[(@_counter)] = (::Quark.mdk_runtime._FakeTimeRequest.new(origin, (sched).event, ((self)._now) + ((sched).seconds)))
1780
1796
 
1781
1797
  nil
1782
1798
  end
@@ -1845,6 +1861,9 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
1845
1861
  if ((name) == ("dispatcher"))
1846
1862
  return (self).dispatcher
1847
1863
  end
1864
+ if ((name) == ("_counter"))
1865
+ return (self)._counter
1866
+ end
1848
1867
  return nil
1849
1868
 
1850
1869
  nil
@@ -1861,6 +1880,9 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
1861
1880
  if ((name) == ("dispatcher"))
1862
1881
  (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
1863
1882
  end
1883
+ if ((name) == ("_counter"))
1884
+ (self)._counter = ::DatawireQuarkCore.cast(value) { ::Integer }
1885
+ end
1864
1886
 
1865
1887
  nil
1866
1888
  end
@@ -1880,6 +1902,7 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
1880
1902
  self._now = 1000.0
1881
1903
  self._scheduled = {}
1882
1904
  self.dispatcher = nil
1905
+ self._counter = 0
1883
1906
 
1884
1907
  nil
1885
1908
  end