wattics-api-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1916eb20d15dc10b81e744dc4d0033999ce05d8
+  data.tar.gz: 53896a7a281ec057f175096933ef31a1932d372d
+SHA512:
+  metadata.gz: 044f756e6c050635ed9655ea7c8e719848366fdb8185fc3274fb5182d50106ca7ace6fcbbc48b2f0cc02d0b079bd0cd9cac392baf754831df2191d6152956ca6
+  data.tar.gz: deabf960f636efb6c8b05e7d0a252d5c784ebfeefbe463119f45d0604cc92ee5897e52656ea4efaf90e5a6697b376b95de88f37cace10dfe594edc85b5630eed

data/lib/wattics-api-client.rb

@@ -0,0 +1,15 @@
+require 'wattics-api-client/version'
+
+require 'wattics-api-client/measurements'
+require 'wattics-api-client/blocking_queue'
+require 'wattics-api-client/config'
+require 'wattics-api-client/client'
+require 'wattics-api-client/measurement_with_config'
+
+require 'wattics-api-client/processor'
+require 'wattics-api-client/processor_pool'
+
+require 'wattics-api-client/agent'
+
+module WatticsApiClient
+end

data/lib/wattics-api-client/agent.rb

@@ -0,0 +1,113 @@
+require 'concurrent'
+
+class Agent
+  @@mutex = Mutex.new
+  attr_reader :thread
+  def initialize(maximum_parallel_senders = 0)
+    @agent_thread_group = ThreadGroup.new
+    @processor_pool = ProcessorPool.new(self, @agent_thread_group, maximum_parallel_senders)
+    @enqueued_measurements_with_config = Hash.new { |h, k| h[k] = [] }
+    @sent_measurements_with_context = BlockingQueue.new
+    @measurement_sent_handler_list = Concurrent::Array.new
+    start_processor_feeder
+    start_measurement_sent_handler_dispatcher
+    @wait_semaphore = Concurrent::Semaphore.new(0)
+  end
+  private_class_method :new
+
+  def self.get_instance(maximum_parallel_senders = 0)
+    @@mutex.synchronize do
+      @@instance ||= new(maximum_parallel_senders)
+    end
+  end
+
+  def self.dispose
+    @@mutex.synchronize do
+      unless @@instance.nil?
+        @@instance.agent_thread_group.list.each(&:kill)
+        @@instance = nil
+      end
+    end
+  end
+
+  def wait_until_last
+    Thread.new do
+      sleep 0.01 while @wait_semaphore.available_permits != 0
+    end.join
+  end
+
+  def start_processor_feeder
+    @agent_thread_group.add(Thread.new do
+      begin
+        loop do
+          key, values = @enqueued_measurements_with_config.first
+          if @enqueued_measurements_with_config.empty?
+            sleep_fix
+            next
+          end
+          processor = @processor_pool.get_processor(key)
+          if processor.nil?
+            sleep_fix
+            next
+          end
+          @enqueued_measurements_with_config.delete(key)
+          processor.process(values)
+        end
+      rescue ThreadError
+      end
+    end)
+  end
+
+  def start_measurement_sent_handler_dispatcher
+    @agent_thread_group.add(Thread.new do
+      begin
+        loop do
+          array = @sent_measurements_with_context.pop
+          next if array.nil?
+          measurement = array[0]
+          response = array[1]
+          @measurement_sent_handler_list.each { |handler| handler.call(measurement, response) }
+        end
+      rescue ThreadError
+      end
+    end)
+  end
+
+  def sleep_fix
+    sleep 0.1
+  end
+
+  def send(measurement, config)
+    if measurement.is_a?(Array)
+      @wait_semaphore.release(measurement.size)
+      measurement_groups = measurement.group_by(&:id)
+      measurement_groups.each do |channel_id, measurements_for_channel_id|
+        measurements_with_config = measurements_for_channel_id.map { |measurement| MeasurementWithConfig.new(measurement, config) }
+        @processor_already_bound_to_channel_id = @processor_pool.get_processor(channel_id)
+        if @processor_already_bound_to_channel_id.nil?
+          @enqueued_measurements_with_config[channel_id] += measurements_with_config
+        else
+          @processor_already_bound_to_channel_id.process(measurements_with_config)
+        end
+      end
+    else
+      @wait_semaphore.release
+      measurement_with_config = MeasurementWithConfig.new(measurement, config)
+      @processor_already_bound_to_channel_id = @processor_pool.get_processor(measurement.id)
+      if @processor_already_bound_to_channel_id.nil?
+        @enqueued_measurements_with_config[measurement.id] << measurement_with_config
+      else
+        @processor_already_bound_to_channel_id.process(measurement_with_config)
+      end
+    end
+  end
+
+  def report_sent_measurement(measurement, response)
+    @sent_measurements_with_context << [measurement, response]
+    @wait_semaphore.acquire
+  end
+
+  def add_measurement_sent_handler
+    @measurement_sent_handler_list << yield
+  end
+end

data/lib/wattics-api-client/blocking_queue.rb

@@ -0,0 +1,36 @@
+class BlockingQueue
+  def initialize
+    @mutex = Mutex.new
+    @queue = []
+    @received = ConditionVariable.new
+  end
+
+  def <<(x)
+    @mutex.synchronize do
+      @queue << x
+      @received.signal
+    end
+  end
+
+  def pop
+    @mutex.synchronize do
+      @received.wait(@mutex) while is_empty?
+      @queue.shift
+    end
+  end
+
+  def is_empty?
+    @queue.empty?
+  end
+end
+
+class PriorityBlockingQueue < BlockingQueue
+  def <<(x)
+    @mutex.synchronize do
+      @queue << x
+      @queue.flatten!
+      @queue.sort!
+      @received.signal
+    end
+  end
+end

data/lib/wattics-api-client/client.rb

@@ -0,0 +1,28 @@
+require 'rest-client'
+
+class Client
+  def send(measurement, config)
+    response = RestClient::Request.execute(method: :post, url: config.uri,
+                                           user: config.username, password: config.password,
+                                           payload: measurement.json)
+    return response
+  rescue RestClient::ExceptionWithResponse => e
+    return  e.response
+  end
+end
+
+class ClientFactory
+  def self.setInstance(client_factory)
+    @instance = client_factory
+  end
+
+  def self.get_instance
+    @instance ||= new
+  end
+
+  def create_client
+    Client.new
+  end
+
+  private_class_method :new
+end

data/lib/wattics-api-client/config.rb

@@ -0,0 +1,20 @@
+class Config
+  attr_reader :environment, :uri, :username, :password
+  PRODUCTION = 'https://web-collector.wattics.com/measurements/v2/unifiedjson/'.freeze
+  DEVELOPMENT = 'https://dev-web-collector.wattics.com/measurements/v2/unifiedjson/'.freeze
+  def initialize(environment, username, password)
+    @environment = environment
+    @uri = environment(environment)
+    @username = username
+    @password = password
+  end
+
+  def environment(environment)
+    if environment == :PRODUCTION
+      PRODUCTION
+    elsif environment == :DEVELOPMENT
+      DEVELOPMENT
+    end
+  end
+
+end

data/lib/wattics-api-client/measurement_with_config.rb

@@ -0,0 +1,11 @@
+class MeasurementWithConfig
+  attr_accessor :measurement, :config
+  def initialize(measurement, config)
+    @measurement = measurement
+    @config = config
+  end
+
+  def <=>(measurementWithConfig)
+    @measurement <=> measurementWithConfig.measurement
+  end
+end

data/lib/wattics-api-client/measurements.rb

@@ -0,0 +1,101 @@
+require 'json'
+require 'time'
+
+class Measurement
+  attr_accessor :id, :timestamp
+
+  def timestamp=(time)
+    @timestamp = time.strftime('%Y-%m-%dT%H:%M:%S.%L%:z')
+  end
+
+  def <=>(measurement)
+    @timestamp <=> measurement.timestamp
+  end
+
+end
+
+class SimpleMeasurement < Measurement
+  attr_accessor :value
+
+  def to_s
+    'SimpleMeasurement{' \
+      "id='" + @id.to_s + '\'' \
+      ', timestamp=' + @timestamp.to_s +
+      ', value=' + @value.to_s +
+      '}'
+  end
+
+  def json
+    {
+      id: @id.to_s,
+      tsISO8601: @timestamp,
+      value: @value
+    }.select { |_k, v| v }.to_json
+  end
+end
+
+class ElectricityMeasurement < Measurement
+  attr_accessor :id, :active_power_phase_a, :active_power_phase_b, :active_power_phase_c,
+                :reactive_power_phase_a, :reactive_power_phase_b, :reactive_power_phase_c,
+                :apparent_power_phase_a, :apparent_power_phase_b, :apparent_power_phase_c,
+                :voltage_phase_a, :voltage_phase_b, :voltage_phase_c,
+                :current_phase_a, :current_phase_b, :current_phase_c,
+                :active_energy_phase_a, :active_energy_phase_b, :active_energy_phase_c,
+                :line_to_line_voltage_phase_ab, :line_to_line_voltage_phase_bc, :line_to_line_voltage_phase_ac
+
+  def to_s
+    'ElectricityMeasurement{' \
+      "id='" + @id.to_s + '\'' \
+      ', timestamp=' + @timestamp.to_s +
+      ', active_power_phase_a=' + @active_power_phase_a.to_s +
+      ', active_power_phase_b=' + @active_power_phase_b.to_s +
+      ', active_power_phase_c=' + @active_power_phase_c.to_s +
+      ', reactive_power_phase_a=' + @reactive_power_phase_a.to_s +
+      ', reactive_power_phase_b=' + @reactive_power_phase_b.to_s +
+      ', reactive_power_phase_c=' + @reactive_power_phase_c.to_s +
+      ', apparent_power_phase_a=' + @apparent_power_phase_a.to_s +
+      ', apparent_power_phase_b=' + @apparent_power_phase_b.to_s +
+      ', apparent_power_phase_c=' + @apparent_power_phase_c.to_s +
+      ', voltage_phase_a=' + @voltage_phase_a.to_s +
+      ', voltage_phase_b=' + @voltage_phase_b.to_s +
+      ', voltage_phase_c=' + @voltage_phase_c.to_s +
+      ', current_phase_a=' + @current_phase_a.to_s +
+      ', current_phase_b=' + @current_phase_b.to_s +
+      ', current_phase_c=' + @current_phase_c.to_s +
+      ', active_energy_phase_a=' + @active_energy_phase_a.to_s +
+      ', active_energy_phase_b=' + @active_energy_phase_b.to_s +
+      ', active_energy_phase_c=' + @active_energy_phase_c.to_s +
+      ', line_to_line_voltage_phase_ab=' + @line_to_line_voltage_phase_ab.to_s +
+      ', line_to_line_voltage_phase_ac=' + @line_to_line_voltage_phase_ac.to_s +
+      ', line_to_line_voltage_phase_bc=' + @line_to_line_voltage_phase_bc.to_s +
+      '}'
+  end
+
+  def json
+    {
+      id: @id.to_s,
+      tsISO8601: @timestamp,
+      aP_1: @active_power_phase_a,
+      aP_2: @active_power_phase_b,
+      aP_3: @active_power_phase_c,
+      rP_1: @reactive_power_phase_a,
+      rP_2: @reactive_power_phase_b,
+      rP_3: @reactive_power_phase_c,
+      apP_1: @apparent_power_phase_a,
+      apP_2: @apparent_power_phase_b,
+      apP_3: @apparent_power_phase_c,
+      v_1: @voltage_phase_a,
+      v_2: @voltage_phase_b,
+      v_3: @voltage_phase_c,
+      c_1: @current_phase_a,
+      c_2: @current_phase_b,
+      c_3: @current_phase_c,
+      pC_1: @active_energy_phase_a,
+      pC_2: @active_energy_phase_b,
+      pC_3: @active_energy_phase_c,
+      v_12: @line_to_line_voltage_phase_ab,
+      v_13: @line_to_line_voltage_phase_ac,
+      v_23: @line_to_line_voltage_phase_bc
+    }.select { |_k, v| v }.to_json
+  end
+end

data/lib/wattics-api-client/processor.rb

@@ -0,0 +1,62 @@
+require 'concurrent'
+require 'nokogiri'
+
+class Processor
+  def initialize(agent)
+    @agent = agent
+    @measurements_with_config = PriorityBlockingQueue.new
+    @semaphore = Concurrent::Semaphore.new(0)
+    @is_sending = false
+    @mutex = Mutex.new
+    @logger = Logger.new(STDOUT)
+    @logger.level = Logger::WARN
+  end
+
+  def process(measurement_with_config)
+    @measurements_with_config << measurement_with_config
+    if measurement_with_config.is_a?(Array)
+      @semaphore.release(measurement_with_config.size)
+    else
+      @semaphore.release
+    end
+  end
+
+  def is_idle?
+    @mutex.synchronize do
+      @measurements_with_config.is_empty? && !@is_sending
+    end
+  end
+
+  def run
+    client = ClientFactory.get_instance.create_client
+    loop do
+      @semaphore.acquire
+      @mutex.synchronize do
+        @measurement_with_config = @measurements_with_config.pop
+        @is_sending = true
+      end
+      @measurement = @measurement_with_config.measurement
+      @config = @measurement_with_config.config
+      loop do
+        begin
+          @response = client.send(@measurement, @config)
+          if !@agent.nil? && @response.code < 400
+            @agent.report_sent_measurement(@measurement, @response)
+          end
+          if !@agent.nil? && @response.code >= 400
+            @logger.error("Could not send #{@measurement}, Server Response: #{Nokogiri::HTML(@response.body).xpath('//h1').text}")
+          end
+          break
+        rescue StandardError => e
+          @logger.error("Could not send #{@measurement}, Server Response: #{e}")
+          sleep 60
+        end
+      end
+      @mutex.synchronize do
+        @is_sending = false
+      end
+    end
+  rescue StandardError => e
+    @logger.error("Thread stopped unexpectedly: #{e.message}")
+  end
+end

data/lib/wattics-api-client/processor_pool.rb

@@ -0,0 +1,40 @@
+class ProcessorPool
+  def initialize(agent, agent_thread_group, maximum_parallel_senders = 0)
+    maximum_parallel_senders > 0 ? @max_processors = maximum_parallel_senders.freeze : @max_processors = (2 * Concurrent.processor_count).freeze
+    @agent = agent
+    @processors = {}
+    @processor_thread_group = agent_thread_group
+    @mutex = Mutex.new
+  end
+
+  def get_processor(channel_id)
+    @mutex.synchronize do
+      processor = @processors[channel_id]
+      return processor unless processor.nil?
+      if @processors.size < @max_processors
+        @processors[channel_id] = spawn_new_processor
+        @processors[channel_id]
+      else
+        rebind_processor_to_channel_id(channel_id)
+      end
+    end
+  end
+
+  private
+
+  def spawn_new_processor
+    processor = Processor.new(@agent)
+    @processor_thread_group.add(Thread.new { processor.run })
+    processor
+  end
+
+  def rebind_processor_to_channel_id(new_channel_id)
+    idle_processor_entry = @processors.select { |_key, value| value.is_idle? }.first
+    return nil if idle_processor_entry.nil?
+    old_channel_id = idle_processor_entry[0]
+    idle_processor = idle_processor_entry[1]
+    @processors.delete(old_channel_id)
+    @processors[new_channel_id] = idle_processor
+    idle_processor
+  end
+end

data/lib/wattics-api-client/version.rb

@@ -0,0 +1,3 @@
+module WatticsApiClient
+  VERSION = '0.1.0'.freeze
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: wattics-api-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wattics
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: thread
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: The gem connects with the wattics API to send over data to the wattics
+  plataform
+email:
+- support@wattics.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wattics-api-client.rb
+- lib/wattics-api-client/agent.rb
+- lib/wattics-api-client/blocking_queue.rb
+- lib/wattics-api-client/client.rb
+- lib/wattics-api-client/config.rb
+- lib/wattics-api-client/measurement_with_config.rb
+- lib/wattics-api-client/measurements.rb
+- lib/wattics-api-client/processor.rb
+- lib/wattics-api-client/processor_pool.rb
+- lib/wattics-api-client/version.rb
+homepage: https://github.com/Wattics/wattics-api-client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: This gem connects with Wattics API
+test_files: []