aethernal-agent 0.1.10

data/lib/aethernal_agent/apache/templates/aa-user.conf.erb

@@ -0,0 +1,21 @@
+# AUTOMATICALLY GENERATED DON'T EDIT THIS FILE UNLESS YOU WANT TO SEE YOUR CHANGES DO _POOF_
+# <%=DateTime.now %>
+<VirtualHost *:80>
+  ServerName <%= @user %>.<%= @container_name %>.<%= @host_name %>
+  <% if @custom_domains.present? %>
+    <% @custom_domains.each do |domain| %>
+  ServerAlias <%= @user %>.<%= domain %>
+    <% end %>
+  <% end %>
+
+  DocumentRoot <%= @home_folder %>/www
+  CustomLog /var/log/apache2/<%= @user %>.base-access.log combined
+  ErrorLog /var/log/apache2/<%= @user %>.base-error.log
+  IncludeOptional users/<%= @user %>/*.conf
+
+  <Directory <%= @home_folder %>/www>
+    AllowOverride all
+    Require all granted
+  </Directory>
+
+</VirtualHost>

data/lib/aethernal_agent/app.rb

@@ -0,0 +1,317 @@
+require 'open-uri'
+require 'aethernal_agent/apt'
+require 'digest/sha1'
+require 'aethernal_agent/filesystem'
+require 'aethernal_agent/systemd'
+require 'aethernal_agent/utils'
+require 'aethernal_agent/errors'
+require 'aethernal_agent/apache/apache'
+require 'active_support'
+require 'active_support/core_ext'
+
+module AethernalAgent
+  class App
+    include AethernalAgent::Apt
+    include AethernalAgent::Filesystem
+    include AethernalAgent::Systemd
+    include AethernalAgent::Utils
+    include AethernalAgent::Errors
+
+    attr_accessor :manifest, :user, :plugin_path, :global_options
+
+    def initialize(options = {})
+      options = HashWithIndifferentAccess.new(options)
+      self.global_options = options
+      self.plugin_path = options[:file_path] || caller_locations(0)[1].path
+      self.user = options[:user]
+
+      AethernalAgent.logger.debug("initializing plugin from #{plugin_path}")
+      self.manifest = OpenStruct.new(YAML.load_file(File.join(File.dirname(self.plugin_path), "manifest.yml")))
+    end
+
+    #FIXME: Add error tracking
+    def install_packages(options = {})
+      directory(home_folder_path("/.config"), owner: self.user)
+      AethernalAgent.logger.info("Installing packages for #{self.manifest.name} - v#{self.manifest.version}")
+
+      if self.manifest.package.has_key?('ppa')
+        self.manifest.package['ppa'].each do |ppa|
+          AethernalAgent.logger.debug("Setting up PPA: #{ppa}")
+          run_command("add-apt-repository ppa:#{ppa} -y")
+        end
+      end
+
+      self.manifest.package.each_key do |package_type|
+        case package_type
+        when 'apt'
+          options = self.manifest.package['apt'][ubuntu_release]
+          AethernalAgent.logger.debug("Using apt for ubuntu #{ubuntu_release} - #{options}")
+          packages = options['packages']
+
+          if options.has_key?('add_sources')
+            AethernalAgent.logger.debug("Adding custom sources")
+            options['add_sources'].each do |name, source|
+              AethernalAgent.logger.debug("Setting up custom apt source '#{name}'")
+              file_path = "/etc/apt/sources.list.d/#{name}.list"
+
+              unless File.exist?(file_path)
+                run_command("echo '#{source['source_url']}' > #{file_path}")
+              else
+                AethernalAgent.logger.debug("Custom apt source '#{name}' already present, not rewriting.")
+              end
+              run_command("curl #{source['key_url']} | sudo apt-key add -") if source['key_url'].present?
+              run_command("sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys #{source['key_id']}") if source['key_id'].present?
+            end
+            apt_update
+          end
+
+          if packages
+            AethernalAgent.logger.debug("Installing packages #{packages}")
+            apt_package(packages: packages)
+          end
+        when 'direct_download'
+          opts = self.manifest.package[package_type]
+          target_file = File.join(app_path, opts["target_name"])
+          directory(app_path, owner: self.user)
+          AethernalAgent.logger.debug("Downloading file from '#{opts["url"]}' to '#{target_file}'")
+          File.open(target_file, "wb") do |saved_file|
+            open(opts["url"], "rb") do |read_file|
+              saved_file.write(read_file.read)
+            end
+          end
+
+          if opts["auto_unzip"]
+            unzip(opts["target_name"], delete_after: true)
+          elsif opts["auto_extract"]
+            extract(opts["target_name"], delete_after: true)
+          end
+        end
+      end
+      AethernalAgent.logger.info("Done Installing packages for #{self.manifest.name} - v#{self.manifest.version}")
+      return create_return_args(options)
+    end
+
+    def uninstall_packages(options = {})
+      AethernalAgent.logger.info("Uninstalling packages for #{self.manifest.name} - v#{self.manifest.version}")
+
+      self.stop
+      self.disable
+
+      self.manifest.package.each_key do |package_type|
+        case package_type
+        when "apt"
+          AethernalAgent.logger.debug("Using apt for ubuntu #{ubuntu_release}")
+          packages = self.manifest.package[package_type][ubuntu_release]
+          AethernalAgent.logger.debug("Removing packages #{packages}")
+          apt_package(packages: packages, action: :remove) if packages
+        when "direct_download"
+          directory(app_path, action: :delete)
+        end
+      end
+
+      return create_return_args(options)
+    end
+
+    def configure_app_user(options={})
+      errors = {}
+      opts, errors = ensure_action_options(__method__,options)
+      return {errors: errors} unless errors.empty?
+
+      if self.manifest.apache_configuration
+        apache = AethernalAgent::Apache.new(opts)
+        errors = apache.ensure_base_config(opts)
+        apache.write_app_config(template_path(self.manifest.apache_configuration), self.manifest.plain_name, opts[:port])
+      end
+
+      AethernalAgent.logger.debug("Running custom plugin code.")
+      yield opts if block_given?
+      AethernalAgent.logger.debug("Done running custom plugin code.")
+
+      AethernalAgent.logger.debug("Starting service generation.")
+      self.manifest.services.each do |s|
+        options = {service_name: "#{s}.service", user: self.user, vars: opts}
+        service_template = template_path("#{s}.service.erb")
+        if File.exists?(service_template)
+          AethernalAgent.logger.debug("Found service template")
+          options[:template] = "#{s}.service.erb"
+        elsif File.exists?(files_path("#{s}.service"))
+          AethernalAgent.logger.debug("Found service file")
+          options[:file] = "#{s}.service"
+        end
+
+        create_service_file(options)
+      end
+      AethernalAgent.logger.debug("Done with service generation.")
+
+      directory(home_folder_path("apps"), owner: self.user)
+
+      AethernalAgent.logger.debug("Done running configure_app_user")
+      return create_return_args(opts)
+    end
+
+    def remove_app_user(options={})
+      opts, errors = ensure_action_options(__method__,options)
+      return {errors: errors} unless errors.empty?
+
+      run_user_systemctl(:stop)
+
+      self.manifest.services.each do |service|
+        file(service_file_path("#{service}.service"), action: :delete)
+      end
+
+      if self.manifest.apache_configuration
+        apache = AethernalAgent::Apache.new(opts)
+        apache.remove_app_config(self.manifest.plain_name)
+      end
+
+      if self.is_local_install?
+        self.uninstall_packages(opts)
+      end
+
+      yield opts if block_given?
+
+      return create_return_args(opts)
+    end
+
+    def create_return_args(options)
+      res = {options: options, errors: get_errors}
+
+      if options[:errors].present?
+        res[:errors] << options.slice(:errors)
+      end
+
+      return res
+    end
+
+    def status(options = {})
+      if options[:service_name]
+        status = get_systemd_status(options[:service_name])
+        return status.to_h if status
+      else
+        stati = self.manifest.services.collect do |service|
+          status = get_systemd_status(service)
+          status.to_h if status
+        end
+
+        return stati
+      end
+    end
+
+    def ensure_action_options(method_name, options={})
+      options = HashWithIndifferentAccess.new(options.reverse_merge(global_options))
+
+      errors = {}
+      AethernalAgent.logger.debug "Running '#{method_name}' with options '#{options}'"
+      if self.manifest.actions.keys.include?(method_name.to_s)
+        opts = self.manifest.actions[method_name.to_s]
+        opts.each do |opt, reqs|
+          AethernalAgent.logger.debug "Checking option #{opt} - requirements: #{reqs}"
+
+          next if reqs.blank?
+
+          # The option is required but has not been supplied
+          if reqs.include?("required") && reqs["required"] == true
+            AethernalAgent.logger.debug("#{opt} is required")
+            if options.has_key?(opt) && !options[opt].blank?
+              AethernalAgent.logger.debug("required option is supplied")
+            else
+              AethernalAgent.logger.debug("required option is not supplied")
+              errors[opt] ||= []
+              errors[opt] << "is required but has not been supplied"
+              next
+            end
+          end
+
+          # This option should be an autogenerated string (passwords)
+          if reqs.include?("auto_generate") && reqs["auto_generate"] == true && (!options.has_key?(opt) || options[opt].empty?)
+            options[opt] = self.random_string
+          end
+
+          # This option should be an autogenerated port
+          if reqs.include?("auto_generate_port") && reqs["auto_generate_port"] == true && (!options.has_key?(opt) || options[opt].blank?)
+            min = reqs["min"] || 2000
+            max = reqs["max"] || 8000
+            options[opt] = random_port(min..max)
+          end
+
+          # The option should be a linux_user
+          if reqs.include?("linux_user") && reqs["linux_user"] == true
+            AethernalAgent.logger.debug "Checking to see if '#{options[:user]}' is a local linux user."
+            begin
+              Etc.getpwnam(options[:user])
+            rescue ArgumentError => e
+              errors[opt] ||= []
+              errors[opt] << e.to_s
+            end
+          end
+        end
+      else
+        puts "Method '#{method_name}' not defined in manifest."
+      end
+
+      return options, errors
+    end
+
+    def app_path(path=nil)
+      full_path = home_folder_path(File.join("apps", self.manifest.package['folder_name']))
+      if path
+        return File.join(full_path, path)
+      else
+        return full_path
+      end
+    end
+
+    def icon_sha
+      if self.manifest.icon.present?
+        return self.manifest.icon["sha256sum"]
+      else
+        return ""
+      end
+    end
+
+    def icon_file(path=nil)
+      if self.manifest.icon.present?
+        icon_path = meta_path(self.manifest.icon['name'])
+        if File.exist?(icon_path)
+          return Base64.encode64(File.read(icon_path))
+        end
+      end
+
+      return nil
+    end
+
+    def extract(source_file, options = {})
+      options.reverse_merge!(extract_to_path: self.app_path, source_folder: self.app_path, auto_detect: true, extract_as: File.extname(source_file))
+
+      extract_from = File.join(options[:source_folder], source_file)
+      extract_to = options[:extract_to_path]
+
+      case options[:extract_as].gsub('.', '')
+      when "gz", "tar"
+        run_command("tar -C #{extract_to} -xvf #{extract_from}")
+      when "zip"
+        run_command("unzip -od #{extract_to} #{extract_from}")
+      else
+        raise "#{options[:extract_as]} not implemented yet"
+      end
+
+      file(extract_from, action: :delete) if options[:delete_after]
+    end
+
+    def unzip(source_file)
+      extract(source_file, extract_as: "zip")
+    end
+
+    def is_local_install?
+      self.manifest.installation_type == 'local_install'
+    end
+
+    def sha_1_hash(password, salt)
+      sha = Digest::SHA1.new
+      sha.update(salt)
+      sha.update(password)
+
+      return sha.hexdigest
+    end
+  end
+end

data/lib/aethernal_agent/apt.rb

@@ -0,0 +1,30 @@
+module AethernalAgent
+  module Apt
+    def apt_update
+      system("apt update")
+    end
+
+    def add_apt_ppa(name)
+      system("add-apt-repository #{name} -y")
+    end
+
+    def apt_package(options = {})
+      action = options[:action]
+      action = :install if action.nil?
+
+      packages = options[:packages]
+      packages = packages.join(" ") if packages.is_a?(Array)
+
+      case action
+      when :install
+        # Do this with popen so we can catch error output as well as normal output for add_errors
+        system("DEBIAN_FRONTEND=noninteractive apt -o DPkg::Options::=--force-confdef install -qy #{packages}")
+      when :remove
+        system("DEBIAN_FRONTEND=noninteractive apt remove -qy #{packages}")
+        system("DEBIAN_FRONTEND=noninteractive apt autoremove -qy")
+      when :autoremove
+        system("DEBIAN_FRONTEND=noninteractive apt autoremove -qy")
+      end
+    end
+  end
+end

data/lib/aethernal_agent/errors.rb

@@ -0,0 +1,17 @@
+module AethernalAgent
+  module Errors
+    attr_accessor :global_errors
+
+    def add_errors(error, vars = {})
+      AethernalAgent.logger.debug("Adding errors: '#{error}'")
+      self.global_errors ||=[]
+      self.global_errors << {method: caller_locations(2,1)[0].label, error: error, args: vars}
+    end
+
+    def get_errors
+      errors = self.global_errors
+      self.global_errors = []
+      return errors
+    end
+  end
+end

data/lib/aethernal_agent/filesystem.rb

@@ -0,0 +1,178 @@
+module AethernalAgent
+  module Filesystem
+    def files_folder
+      File.join(File.expand_path(File.dirname(plugin_path)), "files/")
+    end
+
+    def files_path(file)
+      File.join(files_folder, file)
+    end
+
+    def meta_folder
+      File.join(File.expand_path(File.dirname(plugin_path)), "meta/")
+    end
+
+    def meta_path(file)
+      File.join(meta_folder, file)
+    end
+
+    def templates_folder
+      File.join(File.expand_path(File.dirname(plugin_path)), "templates/")
+    end
+
+    def template_path(file)
+      File.join(templates_folder, file)
+    end
+
+    def home_folder_path(path = nil)
+      if !path.nil?
+        File.join(Dir.home(self.user), path)
+      else
+        File.join(Dir.home(self.user))
+      end
+    end
+
+    def set_ownership(path, user, group=nil)
+      AethernalAgent.logger.debug("Setting ownership of '#{path}' to user '#{user}'")
+      begin
+        FileUtils.chown_R(user,group,path)
+      rescue SystemCallError => e
+        add_errors(e, path: path, user:user, group: group)
+      end
+    end
+
+    def set_permissions(path, chmod)
+      AethernalAgent.logger.debug("Setting chmod of '#{path}' to chmod '#{chmod}'")
+      begin
+        FileUtils.chmod(chmod, path)
+      rescue SystemCallError => e
+        add_errors(e, path: path, chmod: chmod)
+      end
+    end
+
+    def file_settings(file_path, options = {})
+      AethernalAgent.logger.debug "Setting file settings with options: #{options}"
+      set_permissions(file_path, options[:chmod]) if options[:chmod]
+      set_ownership(file_path, options[:owner]) if options[:owner]
+    end
+
+    def file(file_path, options = {})
+      options.reverse_merge!(action: :create)
+
+      AethernalAgent.logger.debug "Applying action #{options[:action]} on file '#{file_path}'."
+
+      if options[:action] == :delete
+        if File.directory?(file_path)
+          add_errors("File is directory, not going to remove it with file() method.", path: file_path)
+        elsif File.exist?(file_path)
+          begin
+            FileUtils.rm(file_path)
+          rescue SystemCallError => e
+            add_errors(e, path: file_path)
+          end
+        else
+          add_errors("File does not exist.", path: file_path)
+        end
+      else
+        set_ownership(file_path, options[:owner]) if options[:owner]
+        set_permissions(file_path, options[:chmod]) if options[:chmod]
+      end
+    end
+
+    def copy(source, target, options = {})
+      AethernalAgent.logger.debug "Applying action #{options[:action]} on file or directory '#{source}'."
+      if source.present? && target.present?
+        if File.directory?(source) || File.exist?(source)
+          if File.exists?(target)
+            add_errors("File or folder already exists.", path: target)
+          else
+            begin
+              if File.directory?(source)
+                FileUtils.cp_r(source, target)
+              else
+                FileUtils.cp(source, target)
+              end
+            rescue SystemCallError => e
+              add_errors(e, path: file_path)
+            end
+          end
+        else
+          add_errors("File or folder does not exist.", path: source)
+        end
+      else
+        add_errors("Source or destination are missing.")
+      end
+    end
+
+    def directory(path, options = {})
+      options.reverse_merge!(action: :create)
+
+      AethernalAgent.logger.debug "Applying action #{options[:action]} on directory '#{path}'."
+      if options[:action] == :create
+        unless File.directory?(path)
+          begin
+            FileUtils.mkdir_p(path)
+          rescue Errno::EEXIST, Errno::EACCES => e
+            add_errors(e, path: path)
+            return
+          end
+        else
+          AethernalAgent.logger.debug "#{path} folder already exist, not creating."
+        end
+
+        set_ownership(path, options[:owner]) if options[:owner]
+        set_permissions(path, options[:chmod]) if options[:chmod]
+      elsif options[:action] == :delete
+        if File.directory?(path)
+          begin
+            FileUtils.rm_r(path)
+          rescue Errno::EACCES => e
+            add_errors(e, path: path)
+          end
+        else
+          AethernalAgent.logger.debug "#{path} does not exist, not removing."
+        end
+      end
+
+      return true
+    end
+
+    def aethernal_agent_folder
+    end
+
+    def aethernal_agent_file(source_file, target_file_path, options = {})
+      AethernalAgent.logger.debug("Attempting to copy file '#{source_file}' to '#{target_file_path}'")
+
+      if File.exists?(target_file_path)
+        AethernalAgent.logger.debug("File already exists, not copying.")
+      else
+        begin
+          FileUtils.cp(File.join(files_folder,source_file), target_file_path)
+        rescue SystemCallError => e
+          AethernalAgent.logger.debug("'#{source_file}' could not be created, giving up. Error: '#{e}'")
+          add_errors(e,source_file: source_file, target_file_path: target_file_path)
+          return false
+        end
+      end
+
+      set_permissions(target_file_path, options[:chmod]) if options[:chmod]
+      set_ownership(target_file_path, options[:owner]) if options[:owner]
+    end
+
+    def write_template(in_path, out_path, vars, options={})
+      out_folder = File.dirname(out_path)
+      unless Dir.exist?(out_folder)
+        FileUtils.mkdir_p(out_folder)
+        set_permissions(out_folder, options[:chmod]) if options[:chmod]
+        set_ownership(out_folder, options[:owner]) if options[:owner]
+      end
+
+      AethernalAgent.logger.debug("Writing template '#{in_path}' to '#{out_path}'")
+      template = AethernalAgent::Template.new(in_path,vars, options)
+
+      if template.parse
+        return template.write_to(out_path)
+      end
+    end
+  end
+end