adminix 0.1.13 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a30b4bcf3c0c5ba6f76a6378a4aa79320414c762
-  data.tar.gz: 60b4e8b3de176c861f46aa5a8fd31fe862c1303a
+  metadata.gz: 95a49d190d16c14ccd3cccc09e06732568f0e9cd
+  data.tar.gz: 5a2e0e20318f38da17a6e4b118ead094c3ae97a3
 SHA512:
-  metadata.gz: b2988e4264ae6105247252199a7b39ebc1749afb01215f58e8b5b979c7aa570b3342a108036cfd38dde6a9ce4459c833cb7b6ad31f69d57067f307bcfd1222b7
-  data.tar.gz: 2722af01f3606b244f5527e565c4a79ab56dd6cb16d1903eec70a26f0442c033cfe35d7c5349beda2bd7a2bd6f91c93b12d27c10ae998070aedbd29960fd02d8
+  metadata.gz: 9452e2d00bfd6e3ac1aafc78a0293d021050e3018f71dfbe183450ce9a169ec701631c7ad43936a9b747952488ae286a11fb99b0f5d51fc523c1850a1514c559
+  data.tar.gz: f1731de81b7c47a8ad54b841496e188a86535e66f2f35bd29530c725809a95596911cb4dd31c87bd6a60c3ea3a2d9dfd30e6b5e89fc02c1d9980b3efc51e5d4b

data/.byebug_history

@@ -1,4 +1,29 @@
 q
+options
+options[:action].to_sym
+parsers[options[:action].to_sym]
+q
+parsers[options[:action].to_sym]
+parsers[:watch]
+parsers
+q
+options
+q
+data["id"]
+data
+type
+q
+message['type']
+message
+q
+message
+q
+data["name"]
+data
+q
+response.body
+data
+q
 System.instance.eval(script)
 script
 args['args'].each { |hs| script.gsub!("%{#{hs[0]}}", hs[1]) }
@@ -229,28 +254,3 @@ service_name
 q
 service_name
 self.service_name = hs['service_name']
-self.service_name
-hs
-q
-hs['service_name']
-hs = JSON.parse(content)
-q
-generate_fake_config_file
-q
-generate_fake_config_file
-q
-rand(1..10000)
-1..10000.rand
-(1..10000).rand
-Faker::Internet.email(name)
-name.sub
-name.join('.')
-name = Faker::Name.name
-name = Faker::Name.namename = Faker::Name.name
-name = Faker::Name.name
-Faker::Internet.email('chris')
-Faker::Internet.email
-q
-require 'faker'
-Faker
-q

data/adminix.gemspec

@@ -32,7 +32,8 @@ Gem::Specification.new do |spec|
 
   #spec.add_dependency "daemons", "~> 1.2.4"
   #spec.add_dependency "action_cable_client", "~> 1.3", ">= 1.3.4"
-  spec.add_dependency "eventmachine", "1.2.2"
+  spec.add_dependency "eventmachine", "1.2.3"
+  spec.add_dependency "em-websocket-client", "0.1.2"
 
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"

data/exe/adminix

@@ -3,7 +3,11 @@
 
 require 'optparse'
 
-options = { action: "help" }
+options = {
+  action: "help",
+  daemonize: false,
+  stop_daemon: false
+}
 parsers = {}
 
 parsers[:env] = OptionParser.new do |opts|
@@ -15,21 +19,10 @@ end
 parsers[:watch] = OptionParser.new do |opts|
   opts.banner =  "Launch Adminix watcher"
   opts.separator "  Usage: adminix watch"
-  #opts.separator "  Usage: adminix watcher [options]"
-  #opts.separator "  Options:"
-  #opts.on("-d", "--daemonize", "run watcher in background process") { options[:daemonize] = true }
-  opts.separator ""
-end
-
-parsers[:generate_daemon] = OptionParser.new do |opts|
-  opts.banner =  "Generate upstart script for watcher"
-  opts.separator "  Usage: adminix generate_daemon"
-  opts.separator ""
-end
-
-parsers[:setup] = OptionParser.new do |opts|
-  opts.banner =  "Generage adminix.json"
-  opts.separator "  Usage: adminix setup"
+  opts.separator "  Usage: adminix watch [options]"
+  opts.separator "  Options:"
+  opts.on("-d", "--daemonize", "run watcher in background process") { options[:daemonize] = true }
+  opts.on("-s", "--stop-daemon", "stop daemon watcher") { options[:stop_daemon] = true }
   opts.separator ""
 end
 
@@ -49,38 +42,6 @@ case options[:action]
     puts Adminix::Service.instance.options_to_envs
   when "watch"
     puts Adminix::Watcher.run!(options)
-  when "generate_daemon"
-    path = Adminix::System.instance.generate_daemon
-    puts "# Daemon has been generated in path #{path}\n" +
-      "# Please execute this command to copy adminix.conf to /etc/init folder:\n" +
-      "sudo mv adminix.conf /etc/init/adminix.conf\n"
-      
-  when "setup"
-    approved = true
-    if Adminix::Config.instance.file_exists?
-      puts "File \"#{ENV['HOME']}/.adminix.json\" already exists, overwrite config (yes/no):"
-      approved = ['yes', 'y'].include?($stdin.gets.chomp)
-    end
-
-    if approved
-      puts "Enter secret key:"
-      secret_key = $stdin.gets.chomp
-       
-      puts "Enter service id (empty to create a new service)"
-      service_id = $stdin.gets.chomp
-       
-      service_name = ''
-      if service_id == ''
-        puts "Enter service name"
-        service_name = $stdin.gets.chomp
-      end
-
-      Adminix::Config.setup(
-        secret_key: secret_key,
-        service_id: service_id,
-        service_name: service_name
-      )
-    end
   when "version"
     puts "adminix version #{Adminix::VERSION}"
   else

data/lib/adminix/config.rb

@@ -1,5 +1,4 @@
 require 'singleton'
-require 'json'
 
 module Adminix
   class Config
@@ -7,128 +6,13 @@ module Adminix
 
     DEFAULT_HOST = 'http://api.adminix.io'.freeze
 
-    attr_accessor(
-      :service_name,
-      :service_id,
-      :service_address,
-      :host,
-      :secret_key,
-      :monitor_logs_paths,
-      :options,
-      :commands
-    )
+    attr_accessor :service_id, :secret_key, :host
 
-    def self.setup(opts)
-      conf = self.instance
-
-      conf.service_id = opts[:service_id] || ENV['ADMINIX_SERVICE_ID']
-      conf.service_name = opts[:service_name]
-      conf.secret_key = opts[:secret_key] || ENV['ADMINIX_SECRET_KEY']
-
-      conf.export
-    end
-
-    def attributes
-      {
-        service_name: service_name,
-        service_id: service_id,
-        service_address: service_address,
-        secret_key: secret_key,
-        options: options || [],
-        commands: commands || []
-      }
-    end
-
-    def file_exists?
-      File.exists?("#{ENV['HOME']}/.adminix.json")
-    end
-
-    def export(path=nil)
-      file_path = path || "#{ENV['HOME']}/.adminix.json"
-      file_content = JSON.pretty_generate(attributes)
-      File.delete(file_path) if File.exists?(file_path)
-      File.open(file_path, 'w') { |file| file.write(file_content) }
-    end
-
-    def import
-      content = File.read(config_file_path)
-      hs = JSON.parse(content)
-
-      self.service_name = hs['service_name']
-      self.service_id = hs['service_id'] || ENV['ADMINIX_SERVICE_ID']
-      self.service_address = hs['service_address']
-      self.secret_key = hs['secret_key'] || ENV['ADMINIX_SECRET_KEY']
-      self.host = hs['host'] || ENV['ADMINIX_CONFIG_HOST'] || DEFAULT_HOST
-      self.options = hs['options'] || []
-      self.commands = hs['commands'] || []
-      
-      valid?
-    end
-
-    def config_file_path
-      return @config_path unless @config_path.nil?
-
-      paths = [
-        "#{ENV['HOME']}/.adminix.json",
-        '.adminix.json'
-      ]
-      paths << ENV['ADMINIX_CONFIG_PATH'] if !ENV['ADMINIX_CONFIG_PATH'].nil?
-
-      config_path = nil
-
-      paths.reverse.each do |path|
-        if File.exists?(path)
-          @config_path = path
-          break
-        end
-      end
-
-      @config_path or raise "adminix.json doesn't exists"
-    end
-
-    def valid?
-      errors = {}
-
-      if service_name.nil?
-        errors[:service_name] ||= []
-        errors[:service_name] << "should't be blank"
-      end
-
-      if service_id.nil?
-        errors[:service_id] ||= []
-        errors[:service_id] << "should't be blank"
-      end
-
-      if secret_key.nil?
-        errors[:secret_key] ||= []
-        errors[:secret_key] << "should't be blank"
-      end
-
-      unless monitor_logs_paths.nil?
-        unless monitor_logs_paths.is_a? Array
-          errors[:monitor_logs_paths] << "should be array"
-        end
-      end
-
-      unless options.nil?
-        unless options.is_a? Array
-          errors[:options] << "should be array"
-        end
-      end
-
-      unless commands.nil?
-        unless commands.is_a? Array
-          errors[:commands] << "should be array"
-        end
-      end
-
-      @errors = errors
-
-      errors.count == 0
-    end
-
-    def errors
-      @errors
+    def initialize
+      self.service_id = ENV['ADMINIX_SERVICE_ID']
+      self.secret_key = ENV['ADMINIX_SECRET_KEY']
+      self.host = ENV['ADMINIX_CONFIG_HOST'] || DEFAULT_HOST 
     end
   end
 end
+

data/lib/adminix/service.rb

@@ -1,132 +1,38 @@
 require 'singleton'
-require 'json'
-require 'net/http'
 
 module Adminix
   class Service
     include Singleton
    
-    attr_accessor :id, :process_id, :name, :address, :completed_commands
+    attr_reader :id, :process_id
 
     def initialize
-      config.import
-
-      self.id = config.service_id
-      self.name = config.service_name
-      self.address = config.service_address
-      self.completed_commands = []
+      @id = config.service_id
     end
 
-    # Send info about container
-    def sync
-      uri = URI.parse("#{config.host}/v1/services/sync")
-      request = Net::HTTP::Post.new(uri)
-      request.content_type = "application/json"
-      request["Authorization"] = "Bearer #{config.secret_key}"
-
-      payload = {
-        service: {
-          id: id,
-          process_id: process_id,
-          completed_commands: completed_commands
+    def to_cable
+      {
+        id: id,
+        process_id: process_id,
+        system: {
+          processor_load: system.processor_load,
+          memory_load: system.memory_load
         }
       }
+    end
 
-      if process_id.nil?
-        payload[:service][:name] = name
-        payload[:service][:address] = address
-        payload[:service][:options] = service_options_payload
-        payload[:service][:commands] = service_commands_payload
-      end
-
-      request.body = payload.to_json
-      req_options = {}
-      response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-        http.request(request)
-      end
-      data = JSON.parse(response.body)['result']
-      
-      self.completed_commands = []
-      self.process_id = data['process_id']
-      
-      if id.nil?
-        self.id = data['id']
-        config.service_id = id
-        config.export
-      end
+    def sync(watcher, data)
+      @process_id = data['process_id']
 
       commands_queue = data['commands_queue'] || []
       commands_queue.each do |q|
         if q['status'] != 'processed'
-          execute_command(q['command_key'], q['process_id'], q['args'] || {})
+          res = execute_command(q['command_key'], q['process_id'], q['args'] || {})
+          watcher.publish_message(:task_completed, res)
         end
       end
     end
 
-    def run_cmd(cmd)
-      `#{cmd}`
-    end
-
-    def config
-      Config.instance
-    end
-
-    def service_options_payload
-      config.options.map do |o|
-        {
-          key: o['key'],
-          name: o['name'],
-          description: o['description'],
-          value_type: o['type'],
-          options: o['options'],
-          validations: o['validations'],
-          default_value: o['default_value'],
-          value: o['default_value']
-        }
-      end
-    end
-
-    def service_commands_payload
-      config.commands.map do |o|
-        {
-          key: o['key'],
-          name: o['name'],
-          description: o['description'],
-          #command: o['command'],
-          arguments: o['arguments']
-        }
-      end
-    end
-
-    def execute_command(key, process_id, args)
-      command = config.commands.find { |c| c['key'] == key }
-      script = command['command'].dup
-      
-      # TODO frontend fix attribute args
-      args['args'].each { |hs| script.gsub!("%{#{hs[0]}}", hs[1]) }
-
-      puts System.instance.eval(script)
-
-      #self.completed_commands << process_id
-
-      uri = URI.parse("#{config.host}/v1/services/#{id}")
-      request = Net::HTTP::Put.new(uri)
-      request.content_type = "application/json"
-      request["Authorization"] = "Bearer #{config.secret_key}"
-
-      payload = {
-        service: {
-          completed_command_process_id: process_id
-        }
-      }
-      request.body = payload.to_json
-      req_options = {}
-      response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
-        http.request(request)
-      end
-      data = JSON.parse(response.body)['result']
-    end
-
     def options_to_envs
       uri = URI.parse("#{config.host}/v1/services/#{id}/options")
       request = Net::HTTP::Get.new(uri)
@@ -145,10 +51,30 @@ module Adminix
         "# eval $(adminix env)"
     end
 
-    def start_watcher
-      loop do
-        puts 'ok'
-      end  
+    private
+
+    def config
+      Config.instance
+    end
+
+    def system
+      System.instance
+    end
+
+    def execute_command(key, process_id, args)
+      command = config.commands.find { |c| c['key'] == key }
+      script = command['command'].dup
+      
+      # TODO frontend fix attribute args
+      args['args'].each { |hs| script.gsub!("%{#{hs[0]}}", hs[1]) }
+
+      output =  system.eval(script)
+    
+      {
+        id: process_id, 
+        success: true,
+        output: output
+      }
     end
   end
 end

data/lib/adminix/version.rb

@@ -1,3 +1,3 @@
 module Adminix
-  VERSION = "0.1.13"
+  VERSION = "0.1.14"
 end

data/lib/adminix/watcher.rb

@@ -1,34 +1,156 @@
 require "eventmachine"
+require "em-websocket-client"
 
 module Adminix
   class Watcher
     def self.run!(options)
-      Watcher.new(options).run!
-    end
+      watcher = Watcher.new(options)
 
-    DEFAULT_PERIOD = 5
+      if options[:stop_daemon]
+        watcher.stop
+      else
+        if options[:daemonize]
+          watcher.start
+        else
+          watcher.run!
+        end
+      end
+    end
 
-    attr_reader :period, :service
+    SYNC_PERIOD = 5.freeze
+    WEBSOCKET_HOST = 'ws://api.adminix.io/websocket'.freeze
+    SERVICE_CHANNEL = 'ServiceChannel'.freeze
 
     def initialize(opts)
-      @period = opts[:period] || DEFAULT_PERIOD
+      @socket_url = opts[:websocket_host] || ENV['ADMINIX_WEBSOCKET_HOST'] || WEBSOCKET_HOST
+      @socket_url = "#{@socket_url}?secret_key=#{config.secret_key}"
       @service = Service.instance
+      @client = nil
+      @pid_full = '/tmp/adminix.pid'
     end
 
     def run!
       trap_signal
-
+      
       EventMachine.run do
-        EventMachine.add_periodic_timer(period) do
-          sync_service
+        @client = WebsocketClient.new(@socket_url) do
+          on_disconnect(@client)
         end
+
+        @client.connect do |message|
+          puts message
+          on_message_receive(@client, message)
+        end
+        
+        EventMachine.add_periodic_timer(SYNC_PERIOD) do
+          publish_message(:sync, @service.to_cable) if @client.connected
+        end
+      end
+    end
+
+    def publish_message(action, data)
+      identifier = { channel: SERVICE_CHANNEL, service_id: @service.id }
+      data = { action: action, data: data }
+
+      @client.publish(identifier, data)
+    end
+
+    def get_pid
+      if File.exists?(@pid_full)
+        file = File.new(@pid_full, "r")
+        pid = file.read
+        file.close
+
+        pid
+      else
+        0
+      end
+    end
+
+    def start
+      pid = get_pid
+      if pid != 0
+        warn "Daemon is already running"
+        exit -1
+      end
+
+      pid = fork {
+        run!
+      }
+      begin
+        file = File.new(@pid_full, "w")
+        file.write(pid)
+        file.close
+        Process.detach(pid)
+      rescue => exc
+        Process.kill('TERM', pid)
+        warn "Cannot start daemon: #{exc.message}"
       end
     end
 
-    def sync_service
-      puts "Syncing service"
-      #puts @service.run_cmd('whoami')
-      service.sync
+    def stop
+      pid = get_pid
+      begin
+        EM.stop
+      rescue
+      end
+
+      if pid != 0
+        Process.kill('HUP', pid.to_i)
+        File.delete(@pid_full)
+        puts "Stopped"
+      else
+        warn "Daemon is not running"
+        exit -1
+      end
+    end
+
+    private
+
+    def config
+      Config.instance
+    end
+
+    def on_message_receive(client, message)
+      case message['type']
+      when 'welcome'
+        puts 'connected to server'
+        on_success_connect(client)
+      when 'ping'
+        puts 'ping from server'
+        # do something
+      else
+        # do something
+      end
+    end
+
+    def on_disconnect(client)
+      puts 'Disconnected. Reconnecting...'
+      client.connect do |message|
+        puts message
+        on_message_receive(client, message)
+      end
+
+      #EventMachine.stop_event_loop
+    end
+
+    def on_success_connect(client)
+      client.subscribe(channel: SERVICE_CHANNEL, service_id: @service.id) do |message|
+        type = message['type'] || message['message']['type']
+        data = message['message']['data'] rescue {} 
+        on_service_message_receive(type, data)
+      end
+    end
+
+    def on_service_message_receive(type, data)
+      puts 'on_service_message_receive'
+      puts type
+      puts data
+      case type
+      when 'confirm_subscription'
+      when 'sync'
+        @service.sync(self, data)
+      end
     end
 
     def trap_signal

data/lib/adminix/websocket_client.rb

@@ -0,0 +1,84 @@
+require 'json'
+
+module Adminix
+  class WebsocketClient
+    attr_accessor :client
+    attr_accessor :connected
+    attr_accessor :connection_handler
+    attr_accessor :channel_handlers
+    attr_accessor :disconnect_handler
+    attr_accessor :url
+
+    def initialize(url, &disconnect_handler)
+      self.url = url
+      self.disconnect_handler = disconnect_handler
+    end
+
+    def connect(&block)
+      self.connection_handler = block
+      self.channel_handlers = {}
+      self.client = EventMachine::WebSocketClient.connect(url)
+      client.callback do
+        puts "Connected WebSocket to #{url}."
+        self.connected = true
+      end
+      client.stream do |raw|
+        message = parse_message(raw.to_s)
+        if message['identifier']
+          channel_handlers[message['identifier'].to_json].call(message)
+        else
+          connection_handler.call(message)
+        end
+      end
+      client.disconnect do
+        self.connected = false
+        disconnect_handler.call
+      end
+     end
+
+    def subscribe(identifier, &block)
+      push(create_subscribe_message(identifier))
+      channel_handlers[identifier.to_json] = block
+    end
+
+    def push(msg)
+      client.send_msg(msg)
+    end
+
+    def publish(identifier, data)
+      msg = create_publish_message(identifier, data)
+      # puts "PUSHING: #{msg}"
+      push(msg)
+    end
+
+    def create_publish_message(identifier, data)
+      message = {
+        command: 'message',
+        identifier: identifier
+      }
+      message[:data] = data.to_json if data
+      message[:identifier] = message[:identifier].to_json
+      message.to_json
+    end
+
+    def create_subscribe_message(identifier)
+      message = {
+          command: 'subscribe',
+          identifier: identifier.to_json
+      }
+      # message[:identifier].merge!(data) if data
+      # message[:data] = data.to_json if data
+      # message[:identifier] = message[:identifier].to_json
+      # puts message
+      message.to_json
+    end
+
+    def parse_message(message)
+      result = JSON.parse(message)
+      result['identifier'] = JSON.parse(result['identifier']) if result['identifier']
+      result['data'] = JSON.parse(result['data']) if result['data']
+      result
+    end
+  end
+end
+

data/lib/adminix.rb

@@ -1,9 +1,9 @@
 require 'adminix/version'
+require 'adminix/websocket_client'
 require 'adminix/config'
 require 'adminix/service'
 require 'adminix/system'
 require 'adminix/watcher'
-require 'adminix/entrypoint'
 
 module Adminix
   def self.root

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adminix
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
 platform: ruby
 authors:
 - Christian Dyl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-12 00:00:00.000000000 Z
+date: 2017-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.2
+        version: 1.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.2
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: em-websocket-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -128,12 +142,13 @@ files:
 - bin/setup
 - exe/adminix
 - lib/adminix.rb
+- lib/adminix/.service.rb.swn
 - lib/adminix/config.rb
-- lib/adminix/entrypoint.rb
 - lib/adminix/service.rb
 - lib/adminix/system.rb
 - lib/adminix/version.rb
 - lib/adminix/watcher.rb
+- lib/adminix/websocket_client.rb
 - views/daemon_scripts/upstart.conf.erb
 homepage: http://adminix.io
 licenses:
@@ -155,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Adminix

data/lib/adminix/entrypoint.rb

@@ -1,68 +0,0 @@
-module Adminix
-  class Entrypoint
-    def self.execute_action(args)
-      action = args[0]
-      case action
-        when 'help' then action_help
-        when 'setup' then action_setup
-        when 'env' then action_env
-        when 'watcher' then action_watcher
-        when 'version' then action_version
-      end
-    end
-
-    def self.action_help
-      puts "Usage: adminix COMMAND\n\n" +
-        "Create and manage Adminix services\n\n" +
-        "Version: #{VERSION}\n\n" +
-        "Author:\n" +
-        "  Christian Dyl\n\n" +
-        "Commands:\n" +
-        "  env        Display the commands to define ENV variables\n" +
-        "  watcher    Launch Adminix watcher\n" +
-        "  setup      Generage adminix.json\n" +
-        "  version    Show the Adminix version"
-    end
-
-    def self.action_setup
-      if Config.instance.file_exists?
-        puts "File \"#{ENV['HOME']}/.adminix.json\" already exists, overwrite config (yes/no):"
-        return unless ['yes', 'y'].include?($stdin.gets.chomp)
-      end
-
-      puts "Enter secret key:"
-      secret_key = $stdin.gets.chomp
-     
-      puts "Enter service id (empty to create a new service)"
-      service_id = $stdin.gets.chomp
-     
-      service_name = ''
-      if service_id == ''
-        puts "Enter service name"
-        service_name = $stdin.gets.chomp
-      end
-
-      Config.setup(
-        secret_key: secret_key,
-        service_id: service_id,
-        service_name: service_name
-      )
-    end
-
-    def self.action_env
-      Service.instance.options_to_envs
-    end
-
-    def self.action_watcher
-      Service.instance.sync
-      #watcher = Watcher.new
-      #watcher.start
-
-      #watcher
-    end
-
-    def self.action_version
-      puts "The current version is #{VERSION}"
-    end
-  end
-end