cosmos 4.5.2 → 5.0.2.pre.beta2

data/lib/cosmos/utilities/store_autoload.rb

@@ -0,0 +1,346 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'redis'
+require 'json'
+require 'connection_pool'
+
+if ENV['COSMOS_REDIS_CLUSTER']
+  require 'enterprise-cosmos/utilities/store'
+  $enterprise_cosmos = true
+else
+  $enterprise_cosmos = false
+end
+
+module Cosmos
+  class Store
+    # Variable that holds the singleton instance
+    @@instance = nil
+
+    # Mutex used to ensure that only one instance is created
+    @@instance_mutex = Mutex.new
+
+    attr_reader :redis_url
+    attr_reader :redis_pool
+
+    # Get the singleton instance
+    def self.instance(pool_size = 100)
+      # Logger.level = Logger::DEBUG
+      return @@instance if @@instance
+
+      @@instance_mutex.synchronize do
+        @@instance ||= self.new(pool_size)
+        return @@instance
+      end
+    end
+
+    if RUBY_VERSION < "3"
+      # Delegate all unknown class methods to delegate to the instance
+      def self.method_missing(message, *args, &block)
+        self.instance.public_send(message, *args, &block)
+      end
+
+      # Delegate all unknown methods to redis through the @redis_pool
+      def method_missing(message, *args, &block)
+        @redis_pool.with { |redis| redis.public_send(message, *args, &block) }
+      end
+    else
+      # Delegate all unknown class methods to delegate to the instance
+      def self.method_missing(message, *args, **kwargs, &block)
+        self.instance.public_send(message, *args, **kwargs, &block)
+      end
+
+      # Delegate all unknown methods to redis through the @redis_pool
+      def method_missing(message, *args, **kwargs, &block)
+        @redis_pool.with { |redis| redis.public_send(message, *args, **kwargs, &block) }
+      end
+    end
+
+    def initialize(pool_size = 10)
+      Redis.exists_returns_integer = true
+      @redis_username = ENV['COSMOS_REDIS_USERNAME']
+      @redis_key = ENV['COSMOS_REDIS_PASSWORD']
+      @redis_url = "redis://#{ENV['COSMOS_REDIS_HOSTNAME']}:#{ENV['COSMOS_REDIS_PORT']}"
+      @redis_pool = ConnectionPool.new(size: pool_size) { build_redis() }
+      @topic_offsets = {}
+    end
+
+    unless $enterprise_cosmos
+      def build_redis
+        return Redis.new(url: @redis_url, username: @redis_username, password: @redis_key)
+      end
+    end
+
+    def get_cmd_item(target_name, packet_name, param_name, type: :WITH_UNITS, scope: $cosmos_scope)
+      msg_id, msg_hash = read_topic_last("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}")
+      if msg_id
+        # TODO: We now have these reserved items directly on command packets
+        # Do we still calculate from msg_hash['time'] or use the times directly?
+        #
+        # if param_name == 'RECEIVED_TIMESECONDS' || param_name == 'PACKET_TIMESECONDS'
+        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).to_f
+        # elsif param_name == 'RECEIVED_TIMEFORMATTED' || param_name == 'PACKET_TIMEFORMATTED'
+        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).formatted
+        if param_name == 'RECEIVED_COUNT'
+          msg_hash['received_count'].to_i
+        else
+          json = msg_hash['json_data']
+          hash = JSON.parse(json)
+          # Start from the most complex down to the basic raw value
+          value = hash["#{param_name}__U"]
+          return value if value && type == :WITH_UNITS
+
+          value = hash["#{param_name}__F"]
+          return value if value && (type == :WITH_UNITS || type == :FORMATTED)
+
+          value = hash["#{param_name}__C"]
+          return value if value && (type == :WITH_UNITS || type == :FORMATTED || type == :CONVERTED)
+
+          return hash[param_name]
+        end
+      end
+    end
+
+    ###########################################################################
+    # Stream APIs
+    ###########################################################################
+
+    def self.initialize_streams(topics)
+      self.instance.initialize_streams(topics)
+    end
+
+    def initialize_streams(topics)
+      @redis_pool.with do |redis|
+        topics.each do |topic|
+          # Create empty stream with maxlen 0
+          redis.xadd(topic, { a: 'b' }, maxlen: 0)
+        end
+      end
+    end
+
+    def self.get_oldest_message(topic)
+      self.instance.get_oldest_message(topic)
+    end
+
+    def get_oldest_message(topic)
+      @redis_pool.with do |redis|
+        result = redis.xrange(topic, count: 1)
+        return result[0]
+      end
+    end
+
+    def self.get_newest_message(topic)
+      self.instance.get_newest_message(topic)
+    end
+
+    def get_newest_message(topic)
+      @redis_pool.with do |redis|
+        result = redis.xrevrange(topic, count: 1)
+        return result[0]
+      end
+    end
+
+    def self.get_last_offset(topic)
+      self.instance.get_last_offset(topic)
+    end
+
+    def get_last_offset(topic)
+      @redis_pool.with do |redis|
+        result = redis.xrevrange(topic, count: 1)
+        if result and result[0] and result[0][0]
+          result[0][0]
+        else
+          "0-0"
+        end
+      end
+    end
+
+    def self.read_topic_last(topic)
+      self.instance.read_topic_last(topic)
+    end
+
+    def read_topic_last(topic)
+      @redis_pool.with do |redis|
+        # Default in xrevrange is range end '+', start '-' which means get all
+        # elements from higher ID to lower ID and since we're limiting to 1
+        # we get the last element. See https://redis.io/commands/xrevrange.
+        result = redis.xrevrange(topic, count: 1)
+        if result and result.length > 0
+          return result[0]
+        else
+          return nil
+        end
+      end
+    end
+
+    # TODO: Currently unused
+    # def decrement_id(id)
+    #   time, sequence = id.split('-')
+    #   if sequence == '0'
+    #     "#{time.to_i - 1}-18446744073709551615"
+    #   else
+    #     "#{time}-#{sequence.to_i - 1}"
+    #   end
+    # end
+
+    def self.update_topic_offsets(topics)
+      self.instance.update_topic_offsets(topics)
+    end
+
+    def update_topic_offsets(topics)
+      offsets = []
+      topics.each do |topic|
+        # Normally we will just be grabbing the topic offset
+        # this allows xread to get everything past this point
+        last_id = @topic_offsets[topic]
+        if last_id
+          offsets << last_id
+        else
+          # If there is no topic offset this is the first call.
+          # Get the last offset ID so we'll start getting everything from now on
+          offsets << get_last_offset(topic)
+          @topic_offsets[topic] = offsets[-1]
+        end
+      end
+      return offsets
+    end
+
+    def self.read_topics(topics, offsets = nil, timeout_ms = 1000, &block)
+      self.instance.read_topics(topics, offsets, timeout_ms, &block)
+    end
+    unless $enterprise_cosmos
+      def read_topics(topics, offsets = nil, timeout_ms = 1000)
+        # Logger.debug "read_topics: #{topics}, #{offsets} pool:#{@redis_pool}"
+        @redis_pool.with do |redis|
+          offsets = update_topic_offsets(topics) unless offsets
+          result = redis.xread(topics, offsets, block: timeout_ms)
+          if result and result.length > 0
+            result.each do |topic, messages|
+              messages.each do |msg_id, msg_hash|
+                @topic_offsets[topic] = msg_id
+                yield topic, msg_id, msg_hash, redis if block_given?
+              end
+            end
+          end
+          # Logger.debug "result:#{result}" if result and result.length > 0
+          return result
+        end
+      end
+    end
+
+    # Add new entry to the redis stream.
+    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xadd
+    #
+    # @example Without options
+    #   COSMOS::Store().write_topic('MANGO__TOPIC', {'message' => 'something'})
+    # @example With options
+    #   COSMOS::Store().write_topic('MANGO__TOPIC', {'message' => 'something'}, id: '0-0', maxlen: 1000, approximate: false)
+    #
+    # @param topic [String] the stream / topic
+    # @param msg_hash [Hash]   one or multiple field-value pairs
+    #
+    # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation
+    # @option opts [Integer] :maxlen      max length of entries
+    # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not
+    #
+    # @return [String] the entry id
+    def self.write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = true)
+      self.instance.write_topic(topic, msg_hash, id, maxlen, approximate)
+    end
+
+    # Add new entry to the redis stream.
+    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xadd
+    #
+    # @example Without options
+    #   store.write_topic('MANGO__TOPIC', {'message' => 'something'})
+    # @example With options
+    #   store.write_topic('MANGO__TOPIC', {'message' => 'something'}, id: '0-0', maxlen: 1000, approximate: true)
+    #
+    # @param topic [String] the stream / topic
+    # @param msg_hash [Hash]   one or multiple field-value pairs
+    #
+    # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation,
+    #   if `nil` id is passed it will be changed to `*`
+    # @option opts [Integer] :maxlen      max length of entries, default value is `nil`, it means will grow forever
+    # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not, default value is `true`
+    #
+    # @return [String] the entry id
+    def write_topic(topic, msg_hash, id = '*', maxlen = nil, approximate = true)
+      id = '*' if id.nil?
+      # Logger.debug "write_topic topic:#{topic} id:#{id} hash:#{msg_hash}"
+      @redis_pool.with do |redis|
+        return redis.xadd(topic, msg_hash, id: id, maxlen: maxlen, approximate: approximate)
+      end
+    end
+
+    # Trims older entries of the redis stream if needed.
+    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xtrim
+    #
+    # @example Without options
+    #   COSMOS::Store.trim_topic('MANGO__TOPIC', 1000)
+    # @example With options
+    #   COSMOS::Store.trim_topic('MANGO__TOPIC', 1000, approximate: true, limit: 0)
+    #
+    # @param topic  [String]  the stream key
+    # @param minid  [Integer] max length of entries to trim
+    # @param limit  [Boolean] whether to add `~` modifier of maxlen or not
+    #
+    # @return [Integer] the number of entries actually deleted
+    def self.trim_topic(topic, minid, approximate = true, limit: 0)
+      self.instance.trim_topic(topic, minid, approximate, limit: limit)
+    end
+
+    # Trims older entries of the redis stream if needed.
+    # > https://www.rubydoc.info/github/redis/redis-rb/Redis:xtrim
+    #
+    # @example Without options
+    #   store.trim_topic('MANGO__TOPIC', 1000)
+    # @example With options
+    #   store.trim_topic('MANGO__TOPIC', 1000, approximate: true, limit: 0)
+    #
+    # @param topic  [String]  the stream key
+    # @param minid  [Integer] mid id length of entries to trim
+    # @param limit  [Boolean] whether to add `~` modifier of maxlen or not
+    #
+    # @return [Integer] the number of entries actually deleted
+    def trim_topic(topic, minid, approximate = true, limit: 0)
+      @redis_pool.with do |redis|
+        return redis.xtrim_minid(topic, minid, approximate: approximate, limit: limit)
+      end
+    end
+
+    # Execute any Redis command. Args must be an array (e.g. ["KEYS", "*"])
+    def self.execute_raw(args)
+      self.instance.execute_raw(args)
+    end
+
+    # Execute any Redis command. Args must be an array (e.g. ["KEYS", "*"])
+    def execute_raw(args)
+      synchronize { |client| client.call(args) }
+    end
+  end
+end
+
+class Redis
+  def xtrim_minid(key, minid, approximate: true, limit: nil)
+    args = [:xtrim, key, :MINID, (approximate ? '~' : nil), minid].compact
+    args.concat([:LIMIT, limit]) if limit
+    synchronize { |client| client.call(args) }
+  end
+end

data/lib/cosmos/utilities/zip.rb

@@ -0,0 +1,21 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'zip'
+require 'zip/filesystem'

data/lib/cosmos/utilities.rb

@@ -1,11 +1,35 @@
 # encoding: ascii-8bit
 
-require 'cosmos/utilities/crc'
-require 'cosmos/utilities/csv'
-require 'cosmos/utilities/logger'
-require 'cosmos/utilities/low_fragmentation_array'
-require 'cosmos/utilities/message_log'
-require 'cosmos/utilities/quaternion'
-require 'cosmos/utilities/ruby_lex_utils'
-require 'cosmos/utilities/simulated_target'
-require 'cosmos/utilities/sleeper'
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+module Cosmos
+  autoload(:Logger, 'cosmos/utilities/logger.rb')
+  autoload(:Authorization, 'cosmos/utilities/authorization.rb')
+  autoload(:Store, 'cosmos/utilities/store_autoload.rb')
+  autoload(:Sleeper, 'cosmos/utilities/sleeper.rb')
+  autoload(:Crc, 'cosmos/utilities/crc.rb')
+  autoload(:Crc16, 'cosmos/utilities/crc.rb')
+  autoload(:Crc32, 'cosmos/utilities/crc.rb')
+  autoload(:Crc64, 'cosmos/utilities/crc.rb')
+  autoload(:Csv, 'cosmos/utilities/csv.rb')
+  autoload(:Metric, 'cosmos/utilities/metric.rb')
+  autoload(:MessageLog, 'cosmos/utilities/message_log.rb')
+  autoload(:Quaternion, 'cosmos/utilities/quaternion.rb')
+  autoload(:SimulatedTarget, 'cosmos/utilities/simulated_target.rb')
+end
+autoload(:RubyLexUtils, 'cosmos/utilities/ruby_lex_utils.rb')

data/lib/cosmos/version.rb

@@ -1,12 +1,13 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '4.5.2'
+COSMOS_VERSION = '5.0.2-beta2'
 module Cosmos
   module Version
-    MAJOR = '4'
-    MINOR = '5'
+    MAJOR = '5'
+    MINOR = '0'
     PATCH = '2'
-    BUILD = 'a516d4699e4de74066155c12194c9286adcde9ea'
+    OTHER = 'beta2'
+    BUILD = '86e4fc1b82d7941b7f77e9257ecafafeff9fe3fd'
   end
-  VERSION = '4.5.2'
+  VERSION = '5.0.2-beta2'
 end

data/lib/cosmos/win32/excel.rb

@@ -1,12 +1,21 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2022 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
+# under the terms of the GNU Affero General Public License
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
 
 require 'win32ole'
 require 'fileutils'

data/lib/cosmos/win32/win32.rb

@@ -1,12 +1,21 @@
 # encoding: ascii-8bit
 
-# Copyright 2014 Ball Aerospace & Technologies Corp.
+# Copyright 2022 Ball Aerospace & Technologies Corp.
 # All Rights Reserved.
 #
 # This program is free software; you can modify and/or redistribute it
-# under the terms of the GNU General Public License
+# under the terms of the GNU Affero General Public License
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
 
 require 'cosmos/win32/win32_main'
 require 'cosmos/packets/structure'
@@ -17,8 +26,10 @@ module Cosmos
     # Create a file
     def self.create_file(filename, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file = NULL)
       api = Win32API.new('Kernel32', 'CreateFile', [LP, DWORD, DWORD, LP, DWORD, DWORD, HANDLE], HANDLE)
+
       handle = api.call(filename, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file)
       raise "Error during CreateFile: #{get_last_error_message()}" if handle == INVALID_HANDLE_VALUE
+
       handle
     end
 
@@ -27,6 +38,7 @@ module Cosmos
       api = Win32API.new('Kernel32', 'CloseHandle', [HANDLE], BOOL)
       result = api.call(handle)
       raise "Error closing handle: #{get_last_error_message()}" if result == 0
+
       result
     end
 
@@ -36,6 +48,7 @@ module Cosmos
       api = Win32API.new('Kernel32', 'GetCommState', [HANDLE, LP], BOOL)
       result = api.call(handle, dcb.buffer)
       raise "GetCommState Error: #{get_last_error_message()}" if result == 0
+
       dcb
     end
 
@@ -44,6 +57,7 @@ module Cosmos
       api = Win32API.new('Kernel32', 'SetCommState', [HANDLE, LP], BOOL)
       result = api.call(handle, dcb.buffer)
       raise "SetCommState Error: #{get_last_error_message()}" if result == 0
+
       result
     end
 
@@ -53,6 +67,7 @@ module Cosmos
       api = Win32API.new('Kernel32', 'SetCommTimeouts', [HANDLE, LP], BOOL)
       result = api.call(handle, comm_timeouts.buffer)
       raise "SetCommTimeouts Error: #{get_last_error_message()}" if result == 0
+
       result
     end
 
@@ -153,7 +168,7 @@ module QDA
       FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x2000
 
       HANDLE_FLAG_INHERIT = 1
-      HANDLE_FLAG_PROTECT_FROM_CLOSE =2
+      HANDLE_FLAG_PROTECT_FROM_CLOSE = 2
 
       STARTF_USESHOWWINDOW = 0x00000001
       STARTF_USESTDHANDLES = 0x00000100
@@ -190,7 +205,8 @@ module QDA
             'P', # pointer to read handle
             'P', # pointer to write handle
             'P', # pointer to security attributes
-            'L'] # pipe size
+            'L'
+          ] # pipe size
 
           createPipe = Cosmos::Win32API.new("kernel32", "CreatePipe", params, 'I')
 
@@ -198,7 +214,7 @@ module QDA
           sec_attrs = [SECURITY_ATTRIBUTES_SIZE, 0, 1].pack('III')
 
           raise_last_win_32_error if createPipe.Call(read_handle,
-                                                      write_handle, sec_attrs, 0).zero?
+                                                     write_handle, sec_attrs, 0).zero?
 
           [read_handle.unpack('I')[0], write_handle.unpack('I')[0]]
         end
@@ -207,12 +223,13 @@ module QDA
           params = [
             'L', # handle to an object
             'L', # specifies flags to change
-            'L'] # specifies new values for flags
+            'L'
+          ] # specifies new values for flags
 
           setHandleInformation = Cosmos::Win32API.new("kernel32",
-                                               "SetHandleInformation", params, 'I')
+                                                      "SetHandleInformation", params, 'I')
           raise_last_win_32_error if setHandleInformation.Call(handle,
-                                                                flags, value).zero?
+                                                               flags, value).zero?
           nil
         end
 
@@ -232,17 +249,18 @@ module QDA
             'L', # IN LPVOID lpEnvironment
             'L', # IN LPCSTR lpCurrentDirectory
             'P', # IN LPSTARTUPINFOA lpStartupInfo
-            'P']  # OUT LPPROCESS_INFORMATION lpProcessInformation
+            'P'
+          ] # OUT LPPROCESS_INFORMATION lpProcessInformation
 
           startupInfo = [STARTUP_INFO_SIZE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW, 0,
-            0, 0, stdin, stdout, stderror].pack('IIIIIIIIIIIISSIIII')
+                         STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW, 0,
+                         0, 0, stdin, stdout, stderror].pack('IIIIIIIIIIIISSIIII')
 
           processInfo = [0, 0, 0, 0].pack('IIII')
           command << 0
 
           createProcess = Cosmos::Win32API.new("kernel32", "CreateProcess", params, 'I')
-          cp_args = [ 0, command, 0, 0, 1, 0, 0, 0, startupInfo, processInfo ]
+          cp_args = [0, command, 0, 0, 1, 0, 0, 0, startupInfo, processInfo]
           raise_last_win_32_error if createProcess.call(*cp_args).zero?
 
           hProcess, hThread,
@@ -260,13 +278,14 @@ module QDA
             'P', # pointer to data to write to file
             'L', # number of bytes to write
             'P', # pointer to number of bytes written
-            'L'] # pointer to structure for overlapped I/O
+            'L'
+          ] # pointer to structure for overlapped I/O
 
           written = [0].pack('I')
           writeFile = Cosmos::Win32API.new("kernel32", "WriteFile", params, 'I')
 
           raise_last_win_32_error if writeFile.call(hFile, buffer, buffer.size,
-                                                     written, 0).zero?
+                                                    written, 0).zero?
 
           written.unpack('I')[0]
         end
@@ -277,7 +296,8 @@ module QDA
             'P', # pointer to buffer that receives data
             'L', # number of bytes to read
             'P', # pointer to number of bytes read
-            'L'] #pointer to structure for data
+            'L'
+          ] # pointer to structure for data
 
           number = [0].pack('I')
           buffer = ' ' * 255
@@ -295,7 +315,8 @@ module QDA
             'L', # size, in bytes, of data buffer
             'L', # pointer to number of bytes read
             'P', # pointer to total number of bytes available
-            'L'] # pointer to unread bytes in this message
+            'L'
+          ] # pointer to unread bytes in this message
 
           available = [0].pack('I')
           peekNamedPipe = Cosmos::Win32API.new("kernel32", "PeekNamedPipe", params, 'I')
@@ -313,13 +334,13 @@ module QDA
           @hError = hError
         end
 
-        def write data
-          Win32Process::write_file(@hWrite, data.to_s)
+        def write(data)
+          Win32Process.write_file(@hWrite, data.to_s)
         end
 
         def read
-          sleep(0.01) while Win32Process::peek_named_pipe(@hRead).zero?
-          Win32Process::read_file(@hRead)
+          sleep(0.01) while Win32Process.peek_named_pipe(@hRead).zero?
+          Win32Process.read_file(@hRead)
         end
 
         def read_all
@@ -331,8 +352,8 @@ module QDA
         end
 
         def read_err
-          sleep(0.01) while Win32Process::peek_named_pipe(@hError).zero?
-          Win32Process::read_file(@hError)
+          sleep(0.01) while Win32Process.peek_named_pipe(@hError).zero?
+          Win32Process.read_file(@hError)
         end
 
         def read_all_err
@@ -362,9 +383,9 @@ module QDA
         set_handle_information(child_error_r, HANDLE_FLAG_INHERIT, 0)
 
         create_process(command,
-                              child_in_r,
-                              child_out_w,
-                              child_error_w)
+                       child_in_r,
+                       child_out_w,
+                       child_error_w)
         # we have to close the handles, so the pipes terminate with the process
         close_handle(child_in_r)
         close_handle(child_out_w)
@@ -377,5 +398,5 @@ module QDA
         return out, err
       end
     end # module Win32Process
-  end #module Filters
+  end # module Filters
 end # module QDA