Module: Cryptum::WebSock::EventMachine

Defined in:
lib/cryptum/web_sock/event_machine.rb

Class Method Summary collapse

Class Method Details

.help ⇒ Object

Display Usage for this Module



175
176
177
178
179
 
# File 'lib/cryptum/web_sock/event_machine.rb', line 175

public_class_method def self.help
  puts "USAGE:
    logger = #{self}.create()
  "
end

.run(opts = {}) ⇒ Object

Supported Method Parameters

Cryptum::WS.run( )



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/cryptum/web_sock/event_machine.rb', line 14

public_class_method def self.run(opts = {})
  env = opts[:env]
  option_choice = opts[:option_choice]
  terminal_win = opts[:terminal_win]
  event_history = opts[:event_history]
  indicator_status = opts[:indicator_status]

  max_conn_attempts = 30
  conn_attempt = 0

  begin
    conn_attempt += 1
    event_history.reconnected = true if conn_attempt > 1

    # Automatically Create Bot Configs if they don't
    # Exist and Initialize Automated Trading Parameters
    bot_conf = Cryptum.read_bot_conf(option_choice: option_choice)

    EM.run do
      # Iterate as fast as possible
      # This ensures candle timing is accurate
      # and everything is fast as possible
      # Defaults to 100ms, 5ms is the lowest possible
      delay_ms = 5
      delay_ms_cast_as_decimal = delay_ms * 0.001
      EM.set_quantum(delay_ms)

      ws = Cryptum::WebSock::Coinbase.connect(
        option_choice: option_choice,
        env: env
      )

      ws.on :open do |_event|
        ws.send(
          Cryptum::WebSock::Coinbase.subscribe_message(
            option_choice: option_choice,
            env: env
          )
        )
      end

      ws.on :message do |event|
        ai_enabled = bot_conf[:artifical_intelligence]
        event_history.event = JSON.parse(
          event.data,
          symbolize_names: true
        )
        event_history.event_type = event_history.event[:type].to_s.to_sym
        event_history = Cryptum::Event.parse(
          env: env,
          terminal_win: terminal_win,
          option_choice: option_choice,
          event_history: event_history,
          indicator_status: indicator_status,
          bot_conf: bot_conf,
          ai_enabled: ai_enabled
        )

        # Decent for Debugging Events
        # puts event_history.inspect
        # Decent for Debugging MACD & RSI History
        # puts indicator_status.inspect

        # Detect Key Press Events
        Cryptum::Event::KeyPress.detect(terminal_win: terminal_win)

        # Get the F* Out (GTFO) when
        # G is pressed
        if terminal_win.key_press_event.key_g
          event_history = Cryptum::API.gtfo(
            option_choice: option_choice,
            env: env,
            event_history: event_history,
            bot_conf: bot_conf
          )
          terminal_win.key_press_event.key_g = false
        end

        # Only Reload Bot Conf when
        # R is Pressed
        if terminal_win.key_press_event.key_r
          bot_conf = Cryptum.read_bot_conf(option_choice: option_choice)
          terminal_win.key_press_event.key_r = false
        end

        # Only Write Order Book to File when
        # W is Pressed
        if terminal_win.key_press_event.key_w
          order_book_file = event_history.order_book[:path]
          File.open(order_book_file, 'w') do |f|
            f.puts event_history.order_book.to_json
          end
          terminal_win.key_press_event.key_w = false
        end

        # Exit if x is Pressed
        if terminal_win.key_press_event.key_x
          terminal_win.key_press_event.key_x = false
          Cryptum.exit_gracefully(
            which_self: self,
            event_history: event_history,
            option_choice: option_choice,
            env: env
          )
        end
      end

      ws.on :close do
        raise Errno::ECONNRESET
      end

      EM.add_periodic_timer(delay_ms_cast_as_decimal) do
        order_countdown = Cryptum::UI::OrderTimer.refresh(
          option_choice: option_choice,
          event_history: event_history,
          order_timer_win: terminal_win.order_timer_section,
          indicator_status: indicator_status,
          key_press_event: terminal_win.key_press_event
        )

        event_history.order_ready = true if order_countdown.zero? ||
                                            order_countdown.negative?
      end

      EM.add_periodic_timer(option_choice.market_trend_reset) do
        Cryptum::OrderBook::MarketTrend.reset(
          option_choice: option_choice,
          terminal_win: terminal_win,
          event_history: event_history,
          bot_conf: bot_conf
        )
      end
    end
  rescue Faye::WebSocket::API::ErrorEvent,
         Errno::ECONNREFUSED,
         Errno::ECONNRESET => e

    File.open('/tmp/cryptum-errors.txt', 'a') do |f|
      f.puts Time.now.strftime('%Y-%m-%d %H:%M:%S.%N %z')
      f.puts "Module: #{self}"
      f.puts "#{e}\n\n\n"
    end

    raise e if conn_attempt > max_conn_attempts

    sleep 1
    retry
  end
rescue Interrupt
  # Exit Gracefully if CTRL+C is Pressed During Session
  Cryptum.exit_gracefully(
    which_self: self,
    event_history: event_history,
    option_choice: option_choice,
    env: env
  )
rescue StandardError => e
  raise e
end