adminix 0.1.49 → 0.2

data/lib/adminix/helpers/files.rb

@@ -0,0 +1,82 @@
+require 'json'
+require 'yaml'
+require 'erb'
+
+module Adminix
+  module Helpers
+    module Files
+      def self.read_json_file(file)
+        content = IO.read(file)
+        JSON.parse(content)
+      rescue JSON::ParserError
+        Helpers::Output.display_error_and_exit(
+          "Error reading JSON inside file #{file}"
+        )
+        {}
+      rescue Errno::ENOENT
+        Helpers::Output.display_error_and_exit("Error reading file #{file}")
+        {}
+      end
+
+      def self.read_yaml_file(file)
+        content = IO.read(file)
+        obj = YAML.safe_load(content)
+        if obj.is_a? String
+          Helpers::Output.display_error_and_exit("Error reading file #{file}")
+          {}
+        end
+        obj
+      rescue Errno::ENOENT
+        Helpers::Output.display_error_and_exit("Error reading file #{file}")
+        {}
+      end
+
+      def self.read_plain_file(file)
+        IO.read(file)
+      rescue Errno::ENOENT
+        Helpers::Output.display_error_and_exit("Error reading file #{file}")
+      end
+
+      def self.write_json_file(file, content)
+        open(file, 'w') { |f| f.puts(content.to_json) }
+      end
+
+      def self.write_yaml_file(file, content)
+        open(file, 'w') { |f| f.puts(content.to_yaml) }
+      end
+
+      def self.write_plain_file(file, content)
+        open(file, 'w') { |f| f.puts(content) }
+      end
+
+      def self.rm(file)
+        File.delete(file) if File.exist?(file)
+      end
+
+      def self.mkdir_p(dirname)
+        `mkdir -p #{dirname}`
+      end
+
+      def self.touch(file_path)
+        `touch #{file_path}`
+      end
+
+      def self.file_exists?(file)
+        File.exist?(file)
+      end
+
+      def self.read_erb_tpl(file, binding)
+        path = "#{Adminix.root}/app/views/web/#{file}.erb"
+        return unless File.exist?(path)
+        template = ERB.new File.read(path), nil, '%'
+        template.result(binding)
+      end
+
+      def self.read_asset(file)
+        path = "#{Adminix.root}/app/assets#{file}"
+        return unless File.exist?(path)
+        IO.read(path)
+      end
+    end
+  end
+end

data/lib/adminix/helpers/log_reader.rb

@@ -0,0 +1,16 @@
+module Adminix
+  module Helpers
+    class LogReader < EventMachine::FileTail
+      def initialize(path, startpos=-1)
+        super(path, startpos)
+        Adminix.logger.info "Tailing #{path}"
+        @buffer = BufferedTokenizer.new
+      end
+
+      def receive_data(data)
+        lines = @buffer.extract(data)
+        Services::LogsService.add_logs(Adminix.watcher, path, lines)
+      end
+    end
+  end
+end

data/lib/adminix/helpers/net_http.rb

@@ -0,0 +1,63 @@
+require 'net/http'
+
+module Adminix
+  module Helpers
+    class NetHTTP
+      def self.get(path)
+        uri = URI.parse("#{Adminix.config.api_host}/v1/#{path}")
+        request = Net::HTTP::Get.new(uri)
+        default_headers.each { |h| request[h[0]] = h[1] }
+
+        opts = { use_ssl: uri.scheme == 'https' }
+        response = Net::HTTP.start(uri.hostname, uri.port, opts) do |http|
+          http.request(request)
+        end
+
+        read_response_body(response)
+      rescue SocketError, Net::OpenTimeout, Net::ReadTimeout
+        Adminix.logger.error("Can't connect to API")
+        [false, nil]
+      end
+
+      def self.post(path, payload)
+        uri = URI.parse("#{Adminix.config.api_host}/v1/#{path}")
+        request = Net::HTTP::Post.new(uri)
+        request.content_type = 'application/json'
+        request.body = payload.to_json
+        default_headers.each { |h| request[h[0]] = h[1] }
+
+        opts = { use_ssl: uri.scheme == 'https' }
+        response = Net::HTTP.start(uri.hostname, uri.port, opts) do |http|
+          http.request(request)
+        end
+
+        read_response_body(response)
+      rescue SocketError, Net::OpenTimeout, Net::ReadTimeout
+        Adminix.logger.error("Can't connect to API")
+        [false, nil]
+      end
+
+      def self.read_response_body(response)
+        unless response.is_a? Net::HTTPSuccess
+          Adminix.logger.error("Received code #{response.code} from API")
+          return [false, response.code]
+        end
+
+        data = JSON.parse(response.body)
+
+        success = data['success'] || false
+        result = data['result']
+
+        [success, result]
+      end
+
+      def self.default_headers
+        [
+          ['Authorization', "Bearer #{Adminix.config.secret_key}"],
+          ['X-Watcher-Version', Adminix::VERSION],
+          ['Accept', 'application/json']
+        ]
+      end
+    end
+  end
+end

data/lib/adminix/helpers/output.rb

@@ -0,0 +1,28 @@
+module Adminix
+  module Helpers
+    module Output
+      def self.display_message(msg)
+        return puts(msg) unless Adminix.test?
+        Adminix.logger.info(msg)
+      end
+
+      def self.display_multiline_message(lines)
+        unless Adminix.test?
+          lines.each { |msg| puts(msg) }
+          return
+        end
+
+        lines.each { |msg| Adminix.logger.info(msg) } 
+      end
+
+      def self.display_error_and_exit(msg)
+        unless Adminix.test?
+          puts "Error: #{msg}"
+          exit
+        end
+
+        Adminix.logger.error(msg)
+      end
+    end
+  end
+end

data/lib/adminix/helpers/systemctl.rb

@@ -0,0 +1,54 @@
+module Adminix
+  module Helpers
+    class Systemctl
+      TMP_SCRIPT_PATH = '/tmp/write_systemctl_script.sh'.freeze
+
+      def initialize(opts = {})
+        @adminix_bin = opts[:adminix_bin] || Helpers::Command.which('adminix')
+        @user = opts[:user] || Helpers::Command.whoami
+        @group = opts[:group] || Helpers::Command.whoami
+        @working_dir = opts[:working_dir] || Helpers::Command.home
+        @systemctl_path = Adminix.config.systemctl[:watcher_service_path]
+      end
+
+      def write
+        Helpers::Files.rm(TMP_SCRIPT_PATH)
+        Helpers::Files.write_plain_file(TMP_SCRIPT_PATH, to_s)
+        Helpers::Output.display_multiline_message([
+          "sudo sh #{TMP_SCRIPT_PATH}",
+          '# Run this command to configure your shell:',
+          '# eval $(adminix write_systemctl)'
+        ])
+      end
+
+      def to_s
+        "#!/bin/bash\n" \
+        "touch #{@systemctl_path}\n" \
+        "cat << EOT > #{@systemctl_path}\n" \
+        "[Unit]\n" \
+        "Description=Adminix\n" \
+        "Requires=network.target\n\n" \
+        "[Service]\n" \
+        "Type=simple\n" \
+        "User=#{@user}\n" \
+        "Group=#{@group}\n" \
+        "WorkingDirectory=#{@working_dir}\n" \
+        "ExecStart=#{@adminix_bin} watch\n" \
+        "Restart=always\n" \
+        "RestartSec=5\n" \
+        "StandardInput=null\n" \
+        "StandardOutput=syslog\n" \
+        "StandardError=syslog\n" \
+        "SyslogIdentifier=%n\n" \
+        "KillMode=mixed\n" \
+        "TimeoutStopSec=5\n" \
+        "TimeoutSec=300\n\n" \
+        "[Install]\n" \
+        "WantedBy=multi-user.target\n" \
+        "EOT\n" \
+        "# Run this command to configure your shell:\n" \
+        '# eval $(adminix write_systemctl)'
+      end
+    end
+  end
+end

data/lib/adminix/services.rb

@@ -0,0 +1,3 @@
+require_relative 'services/logs_service'
+require_relative 'services/app_service'
+require_relative 'services/system_load_service'

data/lib/adminix/services/app_service.rb

@@ -0,0 +1,143 @@
+module Adminix
+  module Services
+    class AppService
+      attr_reader :service
+
+      def initialize(service)
+        @service = service
+      end
+
+      def sync
+        return if !Adminix.config.credentials_defined? || @service.locked?
+
+        service.lock
+        payload = service.sync_payload
+
+        success, result = Helpers::NetHTTP.post(
+          "services/#{service.id}/sync_device",
+          payload
+        )
+        unless success
+          service.unlock
+          return
+        end
+
+        service.reset_performed_actions
+        service.remove_completed_jobs
+        service.clean_sent_logs
+        service.clean_load_stamps
+        service.add_new_jobs(result['jobs'])
+        upgrade_watcher if result['upgrade_watcher'] == true
+        start_process if result['start_process'] == true
+        stop_process if result['stop_process'] == true
+        restart_process if result['restart_process'] == true
+        update_process if result['update_process'] == true
+
+        service.unlock
+      # rescue => e
+        # service.unclock
+      end
+
+      def run_jobs
+        @service.new_jobs[0..1].each(&:perform)
+      end
+
+      def allow_sending_logs
+        @service.allow_sending_logs
+      end
+
+      def allow_sending_system_load
+        @service.allow_sending_system_load
+      end
+
+      def upgrade_watcher
+        Adminix.logger.info 'Upgrading watcher'
+        out = Helpers::Command.run_system_command(
+          Adminix.config.scripts[:upgrade_watcher]
+        )
+
+        [true, out]
+      end
+
+      def update_process
+        Adminix.logger.info 'Updating process'
+        out = Helpers::Command.run_system_command(
+          Adminix.config.scripts[:update_process]
+        )
+        service.define_performed_action(:process_updated, true)
+
+        [true, out]
+      end
+
+      def start_process
+        Adminix.logger.info 'Starting process'
+        out = Helpers::Command.run_system_command(
+          Adminix.config.scripts[:start_process]
+        )
+        service.define_performed_action(:process_stopped, false)
+        service.define_performed_action(:process_started, true)
+
+        [true, out]
+      end
+
+      def restart_process
+        Adminix.logger.info 'Restarting process'
+        stop_process
+        _, out = start_process
+
+        [true, out]
+      end
+
+      def stop_process
+        Adminix.logger.info 'Stopping process'
+        out = Helpers::Command.run_system_command(
+          Adminix.config.scripts[:stop_process]
+        )
+        service.define_performed_action(:process_started, false)
+        service.define_performed_action(:process_stopped, true)
+
+        [true, out]
+      end
+
+      def download_source
+        read_vars
+        list = @service.variables
+        repo_var = list.find { |v| v.key == 'git_repo' }
+        branch_var = list.find { |v| v.key == 'git_branch' }
+
+        if repo_var && repo_var.value && branch_var
+          Helpers::Command.git_clone(repo_var.value, branch_var.value)
+        else
+          puts 'Please define your GIT repository and branch'
+        end
+      end
+
+      def read_vars
+        read_local_vars
+        read_remote_vars
+        write_local_vars
+      end
+
+      def read_local_vars
+        vars_file_path = Adminix.config.config_file('vars')
+        return unless File.exist?(vars_file_path)
+
+        vars = Helpers::Files.read_yaml_file(vars_file_path)
+        vars.each do |k, v|
+          @service.add_variable Entities::Variable.new(key: k, value: v)
+        end
+      end
+
+      def read_remote_vars
+        Entities::Variable.all(@service).each { |v| @service.add_variable(v) }
+      end
+
+      def write_local_vars
+        vars_file_path = Adminix.config.config_file('vars')
+        data = {}
+        @service.variables.each { |v| data[v.key] = v.value }
+        Helpers::Files.write_yaml_file(vars_file_path, data)
+      end
+    end
+  end
+end

data/lib/adminix/services/logs_service.rb

@@ -0,0 +1,13 @@
+module Adminix
+  module Services
+    module LogsService
+      def self.add_logs(watcher, _path, lines)
+        logs = lines.map { |l| Entities::Log.new(l) }
+        watcher.service.add_logs(logs)
+        diff = Adminix.config.data_storage_limit[:logs] -
+               watcher.service.logs.count
+        watcher.service.shift_logs(diff.abs) if diff < 0
+      end
+    end
+  end
+end

data/lib/adminix/services/system_load_service.rb

@@ -0,0 +1,16 @@
+module Adminix
+  module Services
+    class SystemLoadService
+      def initialize(service)
+        @service = service
+      end
+
+      def create_stamp
+        @service.add_system_load(Entities::SysloadStamp.new)
+        diff = Adminix.config.data_storage_limit[:load_stamps] -
+               @service.load_stamps.count
+        @service.shift_load_stamps(diff.abs) if diff < 0
+      end
+    end
+  end
+end

data/lib/adminix/version.rb

@@ -1,3 +1,3 @@
 module Adminix
-  VERSION = '0.1.49'
+  VERSION = '0.2'
 end

data/lib/adminix/watcher.rb

@@ -1,174 +1,106 @@
 require 'eventmachine'
-require 'action_cable_client'
 
 module Adminix
   class Watcher
-    def self.run!(options)
-      watcher = Watcher.new(options)
+    attr_reader :quit
+
+    def self.run!(app_service, options)
+      Adminix.logger.info "Starting watcher PID is #{Process.pid}"
+      EM.run do
+        w = Adminix.watcher = Adminix::Watcher.new(app_service, options)
+        c = Adminix.config
+        p = c.watcher_period
+
+        if c.web_debugger_enabled?
+          Adminix.logger.info "Web debugger is running on port #{c.server_port}"
+          EM.start_server('0.0.0.0', c.server_port, Web::Router)
+        end
+        if Adminix.config.watch_system_load?
+          EM.add_periodic_timer(p[:check_system_load]) { w.perform(:check_system_load) }
+          EM.add_periodic_timer(p[:send_system_load]) { w.perform(:send_system_load) }
+        end
+        if Adminix.config.watch_logs?
+          EM.add_periodic_timer(p[:send_logs]) { w.perform(:send_logs) }
+          Adminix.config.log_files.each do |path|
+            EventMachine.file_tail(path, Adminix::Helpers::LogReader)
+          end
+        end
+        if c.credentials_defined?
+          EM.add_periodic_timer(p[:sync_service]) { w.perform(:sync_service) }
+        end
+        EM.add_periodic_timer(p[:execute_jobs]) { w.perform(:execute_jobs) }
+        EM.add_periodic_timer(2) do
+          if w.quit && !w.wait?
+            Adminix.logger.info 'Stopping watcher...'
+            EM.stop
+          end
+        end
 
-      if options[:stop_daemon]
-        watcher.stop
-      else
-        options[:daemonize] ? watcher.start : watcher.run!
+        trap('TERM') { w.stop }
+        trap('INT') { w.stop }
       end
     end
 
-    SERVICE_CHANNEL = 'ServiceChannel'.freeze
-
-    def initialize(opts)
-      @sync_period = config.watcher_sync_period
-      @pid_full = '/tmp/adminix.pid'
-      @service = Service.instance
-      
-      @ws_client = nil
-      @ws_uri = "#{config.websocket_path}?secret_key=#{config.secret_key}"
-      @ws_channel = { channel: 'ServiceChannel', service_id: @service.id }
-      @ws_logs_channel = { channel: 'LogsChannel', service_id: @service.id }
-
-      @watching_files = []
-
-      if EM.epoll?
-        EM.epoll
-      elsif EM.kqueue?
-        EM.kqueue
-      else
-        Kernel.warn('Neither epoll nor kqueue are supported.')
-      end
+    def initialize(app_service, options)
+      @options = options
+      @running_jobs = []
+      @app_service = app_service
+      @system_load_service = Services::SystemLoadService.new(service)
+      @quit = false
     end
 
-    def run!
-      Adminix::Service.instance.count_logs_lines
-
-      EventMachine.run do
-        Signal.trap("INT")  { EventMachine.stop }
-        Signal.trap("TERM") { EventMachine.stop }
+    def perform(job)
+      return if @running_jobs.include?(job) || @quit
 
-        initialize_ws
-        initialize_ws_logs
-
-        # Sync watcher
-        EventMachine.add_periodic_timer(config.watcher_sync_period) do
-          @ws_client.perform(:sync, @service.to_cable) if @ws_client.subscribed?
-        end
+      @running_jobs << job
+      send(job)
+      @running_jobs.delete(job)
+    end
 
-        # Logs watcher
-        if config.logs_enabled
-          log_files_exists = false
-          config.watch_log_files.each do |file_path|
-            dirname = File.dirname(file_path)
-            Helpers::File.mkdir_p(dirname) unless File.directory?(dirname)
-            Helpers::File.touch(file_path) unless File.exists?(file_path)
-              
-            if File.exists?(file_path)
-              log_files_exists = true
-              EventMachine.watch_file(file_path, Adminix::LogWatchHandler)
-            end
-          end
+    def check_logs
+      Adminix.logger.debug 'Checking logs...'
+    end
 
-          if log_files_exists
-            EventMachine.add_periodic_timer(config.logs_sync_period) do
-              Adminix::Service.instance.sync_logs(@ws_logs_client)
-            end
-          end
-        end
-      end
+    def check_system_load
+      Adminix.logger.debug 'Checking system load...'
+      @system_load_service.create_stamp
     end
 
-    def initialize_ws
-      @ws_client = ActionCableClient.new(@ws_uri, @ws_channel)
-      @ws_client.connected do |msg|
-        puts 'Service connection established'
-      end
-      @ws_client.disconnected do
-        system.log 'Service disconnected. Reconnecting...'
-        sleep(2)
-        # @ws_client.connect!
-        initialize_ws
-      end
-      @ws_client.received do |msg|
-        message = msg['message'] || {}
-        case message['type']
-          when 'restart' then @service.restart!
-          when 'sync' then @service.sync(@ws_client, message['data'])
-        end
-      end
+    def sync_service
+      Adminix.logger.info 'Syncing service...'
+      @app_service.sync
+    end
 
-      # @ws_client.pinged do |_data|
-        # puts 'ping'
-      # end
+    def execute_jobs
+      return unless @app_service.service.new_jobs?
+      Adminix.logger.info 'Executing jobs...'
+      @app_service.run_jobs
     end
 
-    def initialize_ws_logs
-      @ws_logs_client = ActionCableClient.new(@ws_uri, @ws_logs_channel)
-      @ws_logs_client.connected do |msg|
-        puts 'Logs connection established'
-      end
-      @ws_logs_client.disconnected do
-        system.log 'Logs disconnected. Reconnecting...'
-        sleep(2)
-        # @ws_logs_client.connect!
-        initialize_ws_logs
-      end
-      # @ws_logs_client.pinged do |_data|
-        # puts 'logs ping'
-      # end
-      @ws_logs_client.received { |msg| }
+    def send_logs
+      Adminix.logger.debug 'Adding logs to sending queue...'
+      @app_service.allow_sending_logs
     end
 
-    def get_pid
-      if File.exists?(@pid_full)
-        file = File.new(@pid_full, "r")
-        pid = file.read
-        file.close
+    def send_system_load
+      Adminix.logger.debug 'Adding system load to sending queue...'
+      @app_service.allow_sending_system_load
+    end
 
-        pid
-      else
-        0
-      end
+    def wait?
+      !@running_jobs.count.zero?
     end
 
-    def start
-      pid = get_pid
-      if pid != 0
-        warn "Daemon is already running"
-        exit -1
-      end
+    def service
+      @app_service.service
+    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
+    def app_service
+      @app_service
     end
 
     def stop
-      pid = get_pid
-      begin
-        EM.stop
-      rescue
-      end
-
-      if pid != 0
-        Process.kill('HUP', pid.to_i)
-        File.delete(@pid_full)
-        system.log "Stopped"
-      else
-        warn "Daemon is not running"
-        exit -1
-      end
+      @quit = true
     end
-
-    private
-
-    def config() Config.instance end
-    def system() System.instance end
   end
 end
-