huginn_ruby_agent 0.1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46786fbef6ebd0f956499b17915fa8970f4285795073e3f55a9f6d026e8f9597
-  data.tar.gz: 21cf1e531eb5652e34eecf0a8b0151458902f4bee65fe69b5c4110cfe5b2c0f5
+  metadata.gz: 2dcca4b6d669c71c00b5797822e4dfe24c09a0b8344dcd6ad49b9076b7cfe050
+  data.tar.gz: e2580eb01f896a539e98096856a8b79c2416ca04abfa53433f65659cda454cdd
 SHA512:
-  metadata.gz: 2a5c0ebee329f780bdc08637a03803de430cf16753f27f14456380c4cedd598b85a8398a4eb94c1c4355e75a9fc095279e0be90c4032872d8c3159ba934f879b
-  data.tar.gz: 2ecc2518b29ef5f6edfc432325670f8ad09d7f29bb70cd25bc0d09329a87dae0cf9f8053714fd1a335772ce06fd3e106533d9d273ac29034f607aa6399ed433d
+  metadata.gz: d4ad3b1d8bf620b5184cdcc9d84d312bf2fdbb5949f5e9b4311d5ae757855ae329b86745da593ace0c8d8d18434a62bb303abb85756246344944748db9a0b79d
+  data.tar.gz: 0512e8b2944b8e2e542e2529673ed1473062d45e8f8b409f852f31dd78b8d963c215c84dc92366593c77a4b60a14292958daa7ad653dc0da5edabe3fecc64197

data/lib/agents/ruby_agent.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+require 'huginn_ruby_agent'
+require 'huginn_ruby_agent/agent'
+
+module Agents
+  class RubyAgent < Agent
+    include FormConfigurable
+
+    can_dry_run!
+
+    default_schedule "never"
+
+    # TODO: remove redundant
+    gem_dependency_check { defined?(MiniRacer) }
+
+    description <<-MD
+      The Ruby Agent allows you to write code in Ruby that can create and receive events.  If other Agents aren't meeting your needs, try this one!
+
+      You should put code in the `code` option.
+
+      You can implement `Agent.check` and `Agent.receive` as you see fit.  The following methods will be available on Agent:
+
+      * `@api.create_event(payload)`
+      * `@api.incoming_vents()` (the returned event objects will each have a `payload` property) # TODO
+      * `@api.memory()` # TODO
+      * `@api.memory(key)` # TODO
+      * `@api.memory(keyToSet, valueToSet)` # TODO
+      * `@api.set_memory(object)` (replaces the Agent's memory with the provided object) # TODO
+      * `@api.delete_key(key)` (deletes a key from memory and returns the value) # TODO
+      * `@api.credential(name)`
+      * `@api.set_credential(name, valueToSet)`
+      * `@api.options()` # TODO
+      * `@api.options(key)` # TODO
+      * `@api.log(message)`
+      * `@api.error(message)`
+    MD
+
+    form_configurable :code, type: :text, ace: true
+    form_configurable :expected_receive_period_in_days
+    form_configurable :expected_update_period_in_days
+
+    def validate_options
+      errors.add(:base, "The 'code' option is required") unless options['code'].present?
+    end
+
+    def working?
+      return false if recent_error_logs?
+
+      if interpolated['expected_update_period_in_days'].present?
+        return false unless event_created_within?(interpolated['expected_update_period_in_days'])
+      end
+
+      if interpolated['expected_receive_period_in_days'].present?
+        return false unless last_receive_at && last_receive_at > interpolated['expected_receive_period_in_days'].to_i.days.ago
+      end
+
+      true
+    end
+
+
+    def check
+      running_agent do |agent|
+        agent.check
+      end
+    end
+
+    def receive(events)
+      running_agent do |agent|
+        agent.receive events
+      end
+    end
+
+    def default_options
+      code = <<~CODE
+
+        require "bundler/inline"
+
+        gemfile do
+          source "https://rubygems.org"
+
+          # gem "mechanize"
+        end
+
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def check
+            @api.create_event({ message: 'I made an event!' })
+          end
+
+          def receive(incoming_events)
+            incoming_events.each do |event|
+              @api.create_event({ message: 'new event', event_was: event[:payload] })
+            end
+          end
+        end
+      CODE
+
+      {
+        'code' => code,
+        'expected_receive_period_in_days' => '2',
+        'expected_update_period_in_days' => '2'
+      }
+    end
+
+    private
+
+    def running_agent
+      agent = HuginnRubyAgent::Agent.new(code:, credentials: credentials_hash)
+      yield agent
+
+      agent.events.each do |event|
+        create_event(payload: event)
+      end
+      agent.logs.each do |message|
+        log message
+      end
+      agent.errors.each do |message|
+        error message
+      end
+      agent.changed_credentials.each do |name, value|
+        set_credential(name, value)
+      end
+    end
+
+    def code
+      interpolated['code']
+    end
+
+    def credentials_hash
+      Hash[user.user_credentials.map { |c| [c.credential_name, c.credential_value] }]
+    end
+
+    def set_credential(name, value)
+      c = user.user_credentials.find_or_initialize_by(credential_name: name)
+      c.credential_value = value
+      c.save!
+    end
+  end
+end

data/lib/huginn_ruby_agent/agent.rb

@@ -0,0 +1,85 @@
+require 'open3'
+require 'json'
+require 'huginn_ruby_agent/sdk'
+require 'base64'
+
+module HuginnRubyAgent
+  class Agent
+    attr_reader :events, :errors, :logs, :changed_credentials
+
+    def initialize(code:, credentials: {})
+      @code = code
+      @events = []
+      @logs = []
+      @errors = []
+      @credentials = credentials
+      @changed_credentials = {}
+    end
+
+    def check
+      execute ".check"
+    end
+
+    def receive(events)
+      execute ".receive(api.deserialize('#{sdk.serialize(events)}'))"
+    end
+
+    def create_event(payload)
+      @events << payload
+    end
+
+    def log(message)
+      @logs << message
+    end
+
+    def error(message)
+      @errors << message
+    end
+
+    def sdk
+      @sdk ||= SDK.new
+    end
+
+    private
+
+    # https://stackoverflow.com/questions/23884526/is-there-a-safe-way-to-eval-in-ruby-or-a-better-way-to-do-this
+    def execute(command=".check")
+      Bundler.with_original_env do
+        Open3.popen3("ruby", chdir: '/') do |input, output, err, thread|
+          input.write sdk.code
+          input.write @code
+          input.write <<~CODE
+
+          api = Huginn::API.new(serialized_credentials: '#{sdk.serialize(@credentials)}')
+          Agent.new(api)#{command}
+
+          CODE
+          input.close
+
+          output.readlines.map { |line| sdk.deserialize(line) }.each do |data|
+            case data[:action]
+            when 'create_event'
+              create_event(data[:payload])
+            when 'log'
+              log data[:payload]
+            when 'error'
+              error data[:payload]
+            when 'set_credential'
+              @changed_credentials[data[:payload][:name].to_sym] = data[:payload][:value]
+            end
+          end
+
+          log_errors(err)
+        end
+      end
+    rescue StandardError => e
+      error "Runtime error: #{e.message}"
+    end
+
+    def log_errors(err)
+      err.read.lines.each do |line|
+        error line.strip
+      end
+    end
+  end
+end

data/lib/huginn_ruby_agent/sdk.rb

@@ -0,0 +1,70 @@
+require 'json'
+require 'base64'
+
+module HuginnRubyAgent
+  class SDK
+    def serialize(payload)
+      Base64.urlsafe_encode64(payload.to_json)
+    end
+
+    def deserialize(serialized_payload)
+      JSON.parse Base64.urlsafe_decode64(serialized_payload.strip), symbolize_names: true
+    end
+
+    def code
+      <<~CODE
+        require 'json'
+        require 'base64'
+
+        module Huginn
+          class API
+            attr_reader :changed_credentials
+
+            def initialize(serialized_credentials: nil)
+              @serialized_credentials = serialized_credentials
+              @changed_credentials = {}
+            end
+
+            def credentials
+              @credentials ||=
+                begin
+                  @serialized_credentials.nil? ? {} : deserialize(@serialized_credentials) 
+                end
+            end
+
+            def serialize(payload)
+              Base64.urlsafe_encode64(payload.to_json)
+            end
+
+            def deserialize(serialized_payload)
+              JSON.parse Base64.urlsafe_decode64(serialized_payload.strip), symbolize_names: true
+            end
+
+            def credential(name)
+              credentials[name.to_sym]
+            end
+
+            def set_credential(name, value)
+              credentials[name.to_sym] = value
+              changed_credentials[name.to_sym] = value
+
+              puts serialize({ action: :set_credential, payload: { name: name, value: value } })
+            end
+
+            def create_event(payload)
+              puts serialize({ action: :create_event, payload: payload })
+            end
+
+            def log(message)
+              puts serialize({ action: :log, payload: message })
+            end
+
+            def error(message)
+              puts serialize({ action: :error, payload: message })
+            end
+          end
+        end
+      CODE
+    end
+  end
+end

data/lib/huginn_ruby_agent.rb

@@ -2,5 +2,7 @@
 
 require 'huginn_agent'
 
-# HuginnAgent.load 'huginn_ruby_agent/concerns/my_agent_concern'
-HuginnAgent.register 'huginn_ruby_agent/ruby_agent'
+module HuginnRubyAgent
+end
+
+HuginnAgent.register 'agents/ruby_agent'

data/spec/agent_spec.rb

@@ -0,0 +1,135 @@
+require 'huginn_ruby_agent'
+require 'huginn_ruby_agent/agent'
+
+module HuginnRubyAgent
+  describe Agent do
+    describe '#check' do
+      example 'it produces event' do
+        code = <<~CODE
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def check
+            @api.create_event({ message: 'hello' })
+          end
+        end
+        CODE
+
+        agent = described_class.new(code: code)
+        agent.check
+
+        expect(agent.events.size).to eq 1
+        expect(agent.events[0]).to eq(message: 'hello')
+      end
+
+      example "it captures error" do
+        code = <<~CODE
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def check
+            some error here
+          end
+        end
+        CODE
+
+        agent = described_class.new(code: code)
+        agent.check
+
+        expect(agent.events).to be_empty
+        expect(agent.errors).not_to be_empty
+      end
+    end
+
+    describe '#receive' do
+      example 'it produces event' do
+        code = <<~CODE
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def receive(events)
+            events.each do |event|
+              @api.create_event({ number: event[:number] + 1 })
+            end
+          end
+        end
+        CODE
+
+        agent = described_class.new(code: code)
+        agent.receive([{ number: 1 }])
+
+        expect(agent.events.size).to eq 1
+        expect(agent.events[0]).to eq(number: 2)
+      end
+    end
+
+    describe '#logs' do
+      example 'it produces log' do
+        code = <<~CODE
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def check
+            @api.log "hello"
+          end
+        end
+        CODE
+
+        agent = described_class.new(code: code)
+        agent.check
+
+        expect(agent.logs.size).to eq 1
+        expect(agent.logs[0]).to eq "hello"
+      end
+    end
+
+    describe '#credentials' do
+      example 'it gives access to creds' do
+        code = <<~CODE
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def check
+            @api.create_event token_from_credential: @api.credential(:token)
+          end
+        end
+        CODE
+
+        agent = described_class.new(code: code, credentials: { token: 'abc123' })
+        agent.check
+
+        expect(agent.events[0]).to eq({ token_from_credential: 'abc123' })
+      end
+
+      example 'it updates creds' do
+        code = <<~CODE
+        class Agent
+          def initialize(api)
+            @api = api
+          end
+
+          def check
+            @api.set_credential(:token, 'new_val')
+          end
+        end
+        CODE
+
+        agent = described_class.new(code: code, credentials: { token: 'abc123' })
+
+        expect(agent.changed_credentials).to be_empty
+        agent.check
+        expect(agent.changed_credentials).to eq({ token: 'new_val' })
+      end
+    end
+  end
+end

data/spec/sdk_spec.rb

@@ -0,0 +1,22 @@
+require 'huginn_ruby_agent'
+require 'huginn_ruby_agent/sdk'
+
+module HuginnRubyAgent
+  describe SDK do
+    subject(:sdk) { described_class.new }
+
+    def transfered(data)
+      sdk.deserialize(sdk.serialize(data))
+    end
+
+    def expect_to_transfer_safe(data)
+      expect(transfered(data)).to eq data
+    end
+
+    it { expect_to_transfer_safe(1) }
+    it { expect_to_transfer_safe({}) }
+    it { expect_to_transfer_safe({ payload: 1 }) }
+    it { expect_to_transfer_safe({ action: 'create_event', payload: { number: 1 } }) }
+    it { expect_to_transfer_safe({ action: 'create_event', payload: { message: "hello" }}) }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: huginn_ruby_agent
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.3'
 platform: ruby
 authors:
 - Sergei O. Udalov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-26 00:00:00.000000000 Z
+date: 2024-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: huginn_agent
   requirement: !ruby/object:Gem::Requirement
@@ -73,9 +87,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/agents/ruby_agent.rb
 - lib/huginn_ruby_agent.rb
-- lib/huginn_ruby_agent/ruby_agent.rb
-- spec/ruby_agent_spec.rb
+- lib/huginn_ruby_agent/agent.rb
+- lib/huginn_ruby_agent/sdk.rb
+- spec/agent_spec.rb
+- spec/sdk_spec.rb
 homepage: https://github.com/sergio-fry/huginn_ruby_agent
 licenses: []
 metadata: {}
@@ -94,9 +111,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Ruby Agent for Huginn automation platform
 test_files:
-- spec/ruby_agent_spec.rb
+- spec/sdk_spec.rb
+- spec/agent_spec.rb

data/lib/huginn_ruby_agent/ruby_agent.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Agents
-  class RubyAgent < Agent
-    default_schedule '12h'
-
-    description <<-MD
-      Add a Agent description here
-    MD
-
-    def default_options
-      {}
-    end
-
-    def validate_options; end
-
-    def working?
-      # Implement me! Maybe one of these next two lines would be a good fit?
-      # checked_without_error?
-      # received_event_without_error?
-    end
-
-    #    def check
-    #    end
-
-    #    def receive(incoming_events)
-    #    end
-  end
-end

data/spec/ruby_agent_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-require 'huginn_agent/spec_helper'
-
-describe Agents::RubyAgent do
-  before(:each) do
-    @valid_options = Agents::RubyAgent.new.default_options
-    @checker = Agents::RubyAgent.new(name: 'RubyAgent', options: @valid_options)
-    @checker.user = users(:bob)
-    @checker.save!
-  end
-
-  pending 'add specs here'
-end