adminix 0.1.49 → 0.2

data/exe/adminix

@@ -2,9 +2,14 @@
 # encoding: utf-8
 
 require 'optparse'
+require_relative '../lib/adminix'
+
+if ENV['DEBUGGING'] == 'true'
+  require 'byebug'
+end
 
 options = {
-  action: "help",
+  action: 'help',
   secret_key: ENV['ADMINIX_SECRET_KEY'],
   service_id: ENV['ADMINIX_SERVICE_ID'],
   daemonize: false,
@@ -15,6 +20,16 @@ parsers = {}
 parsers[:env] = OptionParser.new do |opts|
   opts.banner =  "Display the commands to define ENV variables"
   opts.separator "  Usage: adminix env [options]"
+  opts.on("--file", "generates .env file") { |key| options[:env_file] ||= "/tmp/#{SecureRandom.uuid}.env" }
+  opts.on("--file-path FILE_PATH", ".env file path") { |key| options[:env_file] = key }
+  opts.on("--secret-key SECRET_KEY", "define api SECRET_KEY") { |key| options[:secret_key] = key }
+  opts.on("--service-id SERVICE_ID", "define api SERVICE_ID") { |id| options[:service_id] = id }
+  opts.separator ""
+end
+
+parsers[:define_credentials] = OptionParser.new do |opts|
+  opts.banner =  'Define Adminix credentials'
+  opts.separator "  Usage: adminix define_credentials [options]"
   opts.on("--secret-key SECRET_KEY", "define api SECRET_KEY") { |key| options[:secret_key] = key }
   opts.on("--service-id SERVICE_ID", "define api SERVICE_ID") { |id| options[:service_id] = id }
   opts.separator ""
@@ -26,6 +41,36 @@ parsers[:download_source] = OptionParser.new do |opts|
   opts.separator ""
 end
 
+parsers[:process_start] = OptionParser.new do |opts|
+  opts.banner = 'Starts a process'
+  opts.separator "  Usage: adminix process_start"
+  opts.separator ""
+end
+
+parsers[:process_restart] = OptionParser.new do |opts|
+  opts.banner = 'Restarts a process'
+  opts.separator "  Usage: adminix process_restart"
+  opts.separator ""
+end
+
+parsers[:process_stop] = OptionParser.new do |opts|
+  opts.banner = 'Stops a process'
+  opts.separator '  Usage: adminix process_stop'
+  opts.separator ''
+end
+
+parsers[:process_update] = OptionParser.new do |opts|
+  opts.banner = 'Updates a process'
+  opts.separator '  Usage: adminix process_update'
+  opts.separator ''
+end
+
+parsers[:write_systemctl] = OptionParser.new do |opts|
+  opts.banner =  'Creates a systemctl file'
+  opts.separator '  Usage: adminix write_systemctl'
+  opts.separator ''
+end
+
 parsers[:watch] = OptionParser.new do |opts|
   opts.banner =  "Launch Adminix watcher"
   opts.separator "  Usage: adminix watch"
@@ -33,8 +78,6 @@ parsers[:watch] = OptionParser.new do |opts|
   opts.separator "  Options:"
   opts.on("--secret-key SECRET_KEY", "define api SECRET_KEY") { |key| options[:secret_key] = key }
   opts.on("--service-id SERVICE_ID", "define api SERVICE_ID") { |id| options[:service_id] = id }
-  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
 
@@ -45,34 +88,54 @@ parsers[:version] = OptionParser.new do |opts|
 end
 
 options[:action] = ARGV[0] || "help"
+options[:logger_mode] = options[:action] == 'watch' && ENV['ADMINIX_LOGGER'].nil? ? 'stdout' : nil
 parsers[options[:action].to_sym].parse!(ARGV) rescue nil
 
-unless options[:action] == "help"
-  require_relative '../lib/adminix'
-  config = Adminix::Config.instance 
-
-  config.secret_key = options[:secret_key]
-  config.service_id = options[:service_id]
-  config.daemon = options[:daemonize]
-  config.read_local_config
-  config.sync_remote_config
+Adminix.config = Adminix::Config.new(options)
+if Adminix.config.credentials_defined?
+  Adminix.config.read_remote_config
+else
+  Adminix.logger.info 'Adminix is not connected to the cloud! Please go to https://adminix.io to create an account.'
 end
+app = Adminix::Services::AppService.new(
+  Adminix::Entities::Service.new(
+    id: Adminix.config.service_id
+  )
+)
+app.read_vars
 
 case options[:action]
-  when "env"
-    puts Adminix::Service.instance.options_to_envs
-  when "download_source"
-    puts Adminix::Service.instance.download_source
-  when "watch"
-    if config.credentials_defined?
-      puts Adminix::Watcher.run!(options)
-    else
-      puts 'Credentials are not defined, running setup server'
-      require_relative '../lib/adminix/server_setup'
-    end
-  when "version"
-    puts "adminix version #{Adminix::VERSION}"
-  else
-    puts parsers.map { |v| v[1].to_s }
+when 'env'
+  app.service.ensure_credentials_exists!
+  puts app.service.bash_variables(options[:env_file])
+when 'download_source'
+  app.service.ensure_credentials_exists!
+  app.download_source
+when 'process_start'
+  _success, output = app.start_process
+  puts output
+when 'process_restart'
+  _success, output = app.restart_process
+  puts output
+when 'process_stop'
+  _success, output = app.stop_process
+  puts output
+when 'process_update'
+  _success, output = app.update_process
+  puts output
+when 'upgrade'
+  _success, output = app.upgrade_watcher
+  puts output
+when 'write_systemctl'
+  Adminix::Helpers::Systemctl.new.write
+when 'define_credentials'
+  Adminix.config.input(:service_id) if options[:service_id].nil?
+  Adminix.config.input(:secret_key) if options[:secret_key].nil?
+  Adminix.config.export_credentials
+when 'watch'
+  Adminix::Watcher.run!(app, options)
+when 'version'
+  puts "adminix version #{Adminix::VERSION}"
+else
+  puts parsers.map { |v| v[1].to_s }
 end
-

data/lib/adminix.rb

@@ -1,15 +1,52 @@
+require_relative 'event_machine'
 require_relative 'adminix/version'
-# require 'adminix/errors'
 require_relative 'adminix/helpers'
 require_relative 'adminix/config'
-require_relative 'adminix/service'
-require_relative 'adminix/system'
-require_relative 'adminix/log_watch_handler'
+require_relative 'adminix/entities'
+require_relative 'adminix/services'
+require_relative 'adminix/web'
 require_relative 'adminix/watcher'
 
 module Adminix
   def self.root
     File.dirname __dir__
   end
-end
 
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.config
+    @config
+  end
+
+  def self.watcher=(watcher)
+    @watcher = watcher
+  end
+
+  def self.watcher
+    @watcher
+  end
+
+  def self.os
+    return @os if @os
+    @os = if RUBY_PLATFORM =~ /darwin/ then 'mac'
+          elsif RUBY_PLATFORM =~ /linux/ then 'linux'
+          elsif RUBY_PLATFORM =~ /mswin32/ then 'windows'
+          else 'unknown'
+          end
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.define_logger(source, lvl = nil)
+    @logger = Logger.new(source)
+    @logger.level = lvl if lvl
+  end
+
+  def self.test?
+    ENV['ADMINIX_ENV'] == 'test'
+  end
+end

data/lib/adminix/config.rb

@@ -1,138 +1,212 @@
-require 'singleton'
-require 'json'
+require 'logger'
+require 'erb'
 
 module Adminix
   class Config
-    include Singleton
-
-    DEFAULT_HOST = 'https://api.adminix.io'.freeze
-    DEFAULT_WEBSOCKET_HOST = 'wss://websocket.adminix.io/cable'.freeze
-    DEFAULT_SETUP_SERVER_PORT = (ENV['ADMINIX_SETUP_SERVER_PORT'] || '8080').freeze
-    DEFAULT_WATCHER_SYNC_PERIOD = 10.freeze
-    DEFAULT_LOGS_SYNC_PERIOD = 3.freeze
-    DEFAULT_LOGS_ENABLED = true
-
-    attr_accessor :service_id, :secret_key, :host, :commands, :daemon, :setup_server_port, :scripts, :watch_log_files, :watcher_sync_period, :logs_sync_period, :logs_enabled, :websocket_path, :mode, :working_dir, :iv, :password
-    attr_reader :image_sname, :error_notifier_enabled
-
-    def initialize
-      @host = ENV['ADMINIX_HOST'] || DEFAULT_HOST
-      @setup_server_port = ENV['ADMINIX_SETUP_SERVER_PORT'] || DEFAULT_SETUP_SERVER_PORT
-      @commands = []
-      @watcher_sync_period = DEFAULT_WATCHER_SYNC_PERIOD
-      @logs_sync_period = DEFAULT_LOGS_SYNC_PERIOD
-      @logs_enabled = DEFAULT_LOGS_ENABLED
-      @websocket_path = ENV['ADMINIX_WEBSOCKET_HOST'] || DEFAULT_WEBSOCKET_HOST
-      @mode = 'classic'
-      @working_dir = `pwd`.split("\n").first
-      @iv = ENV['DECIPHER_IV'] || 'U7yfLthY77Yjtp9z'
+    attr_reader :service_id, :secret_key, :image, :watcher_period, :api_host,
+                :server_port, :config_root_path, :log_files, :max_logs_storage,
+                :data_storage_limit, :systemctl, :scripts, :watch_system_load
+
+    MODE_CLASSIC = 'classic'.freeze
+    DEFAULT_API_HOST = 'https://api.adminix.io'.freeze
+    DEFAULT_SERVER_PORT = 8080
+    WATCHER_SYSTEMCTL_PATH = '/etc/systemd/system/adminix.service'.freeze
+
+    def initialize(props = {})
+      @api_host = ENV['ADMINIX_HOST'] || DEFAULT_API_HOST
+      @service_id = props[:service_id] || ENV['ADMINIX_SERVICE_ID']
+      @secret_key = props[:secret_key] || ENV['ADMINIX_SECRET_KEY']
+      @server_port = props[:server_port] || ENV['ADMINIX_SERVER_PORT'] ||
+                     DEFAULT_SERVER_PORT
+      @config_root_path = props[:config_root_path] ||
+                          "#{ENV['HOME']}/.config/adminix"
+      @watcher_period = {
+        sync_service: 5,
+        send_logs: 10,
+        send_system_load: 10,
+        execute_jobs: 5,
+        check_system_load: 5
+      }
       @scripts = {
-        watcher_start: 'sudo systemctl start adminix.service',
-        watcher_stop: 'sudo systemctl stop adminix.service',
-        process_start: 'sudo systemctl start adminix_process.service',
-        process_stop: 'sudo systemctl stop adminix_process.service',
-        run_script: '~/.config/adminix/scripts/run_script'
+        restart_watcher: "#{@config_root_path}/scripts/restart_watcher",
+        upgrade_watcher: "#{@config_root_path}/scripts/upgrade_watcher",
+        update_process: "#{@config_root_path}/scripts/update_process",
+        start_process: "#{@config_root_path}/scripts/start_process",
+        stop_process: "#{@config_root_path}/scripts/stop_process",
+        run_script: "#{@config_root_path}/scripts/run_script"
+      }
+      @log_files = []
+      @data_storage_limit = {
+        logs: 1000 || ENV['ADMINIX_MAX_LOGS_IN_MEMORY'],
+        load_stamps: 100 || ENV['ADMINIX_MAX_LOAD_STAMPS_IN_MEMORY']
       }
-      @watch_log_files = []
-      @error_notifier_enabled = ENV['ADMINIX_ERROR_NOTIFIER'].nil? ? true : ENV['ADMINIX_ERROR_NOTIFIER'] == 'true'
+      @watch_logs = true
+      @watch_system_load = true
+      @systemctl = {
+        watcher_service_path: ENV['ADMINIX_WATCHER_SYSTEMCTL_PATH'] || WATCHER_SYSTEMCTL_PATH
+      }
+      @logger_mode = props[:logger_mode] || ENV['ADMINIX_LOGGER'] || 'silent'
+      @logger_path = ENV['ADMINIX_LOGGER_PATH']
 
-      @config_store_path = "#{ENV['HOME']}/.config"
-      @root_path = "#{@config_store_path}/adminix"
-      @creds_path = "#{@root_path}/credentials"
-      @config_path = "#{@root_path}/config"
+      setup_logger
+      create_config_root_if_not_exists
+      read_credentials_file unless credentials_defined?
+      read_config_file
+      create_default_scripts
     end
 
+    def setup_logger
+      case @logger_mode
+      when 'stdout'
+        Adminix.define_logger(STDOUT, Logger::INFO)
+      when 'debug'
+        Adminix.define_logger(STDOUT)
+      when 'silent'
+        Adminix.define_logger(STDOUT, Logger::FATAL)
+      when 'file'
+        Helpers::Files.touch(@logger_path) unless @logger_path.nil?
+        if File.exist?(@logger_path)
+          Adminix.define_logger(@logger_path)
+        else
+          Adminix.define_logger(STDOUT)
+          Adminix.logger.error(
+            "Logger can't create file #{@logger_path}, using STDOUT by default"
+          )
+        end
+      else
+        incorrect_mode = @logger_mode
+        @logger_mode = 'stdout'
+        Adminix.define_logger(STDOUT)
+        Adminix.logger.error(
+          "#{incorrect_mode} is incorrect mode for Logger, using STDOUT by default"
+        )
+      end
+    end
 
-    def read_local_config
-      if File.exists?(@creds_path)
-        content = IO.read(@creds_path)
-        data = JSON.parse(content) rescue {}
+    def read_credentials_file
+      credentials_path = config_file('credentials')
+      return unless File.exist?(credentials_path)
 
-        @service_id ||= data['service_id']
-        @secret_key ||= data['secret_key']
-      end
+      data = Helpers::Files.read_json_file(credentials_path)
 
-      if File.exists?(@config_path)
-        content = IO.read(@config_path)
-        data = JSON.parse(content) rescue {}
-
-        @mode = data['mode'] || 'classic'
-        @working_dir = data['working_dir'] if data['working_dir']
-
-        scripts = data['scripts'] || {}
-        @scripts = {
-          watcher_start: scripts['watcher_start'],
-          watcher_stop: scripts['watcher_stop'],
-          process_start: scripts['process_start'],
-          process_stop: scripts['process_stop']
-        }
-        unless scripts['run_script'].nil?
-          @scripts[:run_script] = scripts['run_script']
-        end
+      if data['service_id'].nil? || data['secret_key'].nil?
+        Helpers::Output.display_error_and_exit(
+          'Credentials file is incorrect!'
+        )
+      end
 
-        @watch_log_files = data['watch_logs'] || []
+      @service_id ||= data['service_id']
+      @secret_key ||= data['secret_key']
+    end
 
-        @image_sname = data['image']
+    def read_config_file
+      config_path = config_file('config')
+      unless File.exist?(config_path)
+        Helpers::Files.write_json_file(config_path, {})
+        return
       end
+
+      data = Helpers::Files.read_json_file(config_path)
+      validate_config_file(data)
+
+      @mode = data['mode'] || MODE_CLASSIC
+      @image = data['image']
+      @web_debugger_enabled = data['enable_web_debugger'] || false
+      @working_dir = data['working_dir']
+      @log_files = data['watch_logs'] || []
+      @watch_logs = @log_files.any?
+      @watch_system_load = data['system_load_enabled'] || false
     end
 
-    def sync_remote_config
-      return if service_id.nil? || secret_key.nil?
+    def read_remote_config
+      return unless credentials_defined?
+      Adminix.logger.info('Reading remote config...')
+
+      success, result = Helpers::NetHTTP.get("services/#{@service_id}/watcher_config")
+      return unless success
 
-      uri = URI.parse("#{@host}/v1/services/#{@service_id}/watcher_config")
-      request = Net::HTTP::Get.new(uri)
-      request["Authorization"] = "Bearer #{@secret_key}"
+      @watcher_period[:sync_service] = result['sync_period']
+      @watcher_period[:send_logs] = result['logs_sync_period']
+      @watcher_period[:send_system_load] = result['system_load_sync_period'] || 10
+      @watch_logs = result['logs_enabled']
+      @watch_system_load = result['system_load_enabled'] || false
+    end
 
-      opts = { use_ssl: uri.scheme == 'https' }
-      response = Net::HTTP.start(uri.hostname, uri.port, opts) do |http|
-        http.request(request)
+    def validate_config_file(data)
+      errors = []
+      if data['mode'] && !%w[classic docker].include?(data['mode'])
+        errors << 'incorrect mode type, can be "classic" or "docker"'
       end
- 
-      data = JSON.parse(response.body)
-      result = data['result'] || {}
 
-      case response.code
-      when '401'
-        puts 'Incorrect credentials'
+      if errors.count > 0
+        errors.each { |e| puts e }
         exit
+      else
+        true
       end
-
-      @watcher_sync_period = result['sync_period'] || DEFAULT_WATCHER_SYNC_PERIOD
-      @logs_sync_period = result['logs_sync_period'] || DEFAULT_LOGS_SYNC_PERIOD
-      @logs_enables = result.key?('logs_enabled') ? result['logs_enabled'] == true : DEFAULT_LOGS_ENABLED
     end
 
     def export_credentials
-      create_config_root_if_not_exists
+      file = config_file('credentials')
+      content = { service_id: @service_id, secret_key: @secret_key }
+
+      Helpers::Files.mkdir_p(config_root_path)
+      Helpers::Files.write_json_file(file, content)
+      Helpers::Output.display_message("File #{file} created")
+    end
 
-      open(@creds_path, 'w') do |f|
-        f.puts(credentials.to_json)
+    def input(key)
+      case key
+      when :service_id
+        Helpers::Output.display_message('Please enter your service ID')
+        @service_id = STDIN.gets.chomp
+      when :secret_key
+        Helpers::Output.display_message('Please enter your secret key')
+        @secret_key = STDIN.gets.chomp
+      else
+        Helpers::Output.display_error_and_exit("#{key} is wrong config key")
       end
     end
 
-    def creds_file_exists?
-      File.exists?(@creds_path)
+    def create_default_scripts
+      unless Dir.exist?("#{config_root_path}/scripts")
+        Helpers::Files.mkdir_p("#{config_root_path}/scripts")
+      end
+
+      Dir["#{Adminix.root}/app/views/scripts/*"].each do |tpl_path|
+        script_name = tpl_path.split('/').last.split('.sh.erb').first
+        script_path = "#{config_root_path}/scripts/#{script_name}"
+        next if File.exist?(script_path)
+        tpl = File.open(tpl_path, 'rb', &:read)
+        content = ERB.new(tpl).result(binding)
+        Helpers::Files.write_plain_file(script_path, content)
+        File.chmod(0o755, script_path)
+      end
     end
 
     def credentials_defined?
-      !service_id.nil? && !secret_key.nil?
+      !@service_id.nil? && !@secret_key.nil?
     end
 
-    private
+    def watch_logs?
+      @watch_logs == true
+    end
+
+    def watch_system_load?
+      @watch_system_load == true
+    end
 
-    def credentials
-      { service_id: @service_id, secret_key: @secret_key }
+    def web_debugger_enabled?
+      @web_debugger_enabled == true
     end
 
     def create_config_root_if_not_exists
-      unless Dir.exists?(@config_store_path)
-        Dir.mkdir(@config_store_path)
-      end
+      return if Dir.exists?(config_root_path)
+      Helpers::Files.mkdir_p(config_root_path)
+    end
 
-      unless Dir.exists?(@root_path)
-        Dir.mkdir(@root_path)
-      end
+    def config_file(file)
+      "#{config_root_path}/#{file}"
     end
   end
 end
-