smartmachine 0.8.0 → 0.9.0

data/lib/smart_machine/commands/utilities.rb

@@ -0,0 +1,37 @@
+module SmartMachine
+  module Commands
+    module Utilities
+
+      private
+
+      def in_machine_dir?
+        File.file?("./config/master.key")
+      end
+
+      def inside_machine_dir
+        if in_machine_dir?
+          yield
+        else
+          puts "Are you in the correct directory to run this command?"
+        end
+      end
+
+      def inside_engine_machine_dir
+        if ENV["INSIDE_ENGINE"] == "yes" && File.file?('./bin/smartengine')
+          yield
+        else
+          raise "Not inside the engine machine dir to run this command"
+        end
+      end
+
+      def with_docker_running
+        machine = SmartMachine::Machine.new
+        if machine.run_on_machine(commands: "docker info &>/dev/null")
+          yield
+        else
+          puts "Error: Docker daemon is not running. Have you installed docker? Please ensure docker daemon is running and try again."
+        end
+      end
+    end
+  end
+end

data/lib/smart_machine/commands.rb

@@ -0,0 +1,66 @@
+require 'thor'
+require 'smart_machine'
+
+require 'smart_machine/commands/utilities'
+
+require 'smart_machine/commands/app'
+require 'smart_machine/commands/buildpacker'
+require 'smart_machine/commands/credentials'
+require 'smart_machine/commands/docker'
+require 'smart_machine/commands/engine'
+require 'smart_machine/commands/grid'
+require 'smart_machine/commands/machine'
+require 'smart_machine/commands/syncer'
+
+module SmartMachine
+  module Commands
+    class CLI < Thor
+      include Utilities
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "new [NAME]", "Creates a new machine using the given name"
+      option :dev, type: :boolean, default: false
+      def new(name)
+        raise "Can't create a machine inside a machine. Please come out of the machine directory to create another machine." if in_machine_dir?
+
+        machine = SmartMachine::Machine.new
+        machine.create(name: name, dev: options[:dev])
+      end
+
+      desc "--version", "Shows the current SmartMachine version"
+      map ["--version", "-v"] => :version
+      def version
+        puts "SmartMachine #{SmartMachine.version}"
+      end
+
+      desc "app", "Run app commands"
+      subcommand "app", App
+
+      desc "buildpacker", "Run buildpacker commands"
+      subcommand "buildpacker", Buildpacker
+
+      desc "credentials:edit", "Allows editing the credentials"
+      subcommand "credentials:edit", Credentials
+
+      desc "docker", "Run docker commands"
+      subcommand "docker", Docker
+
+      desc "engine", "Run engine commands"
+      subcommand "engine", Engine
+
+      desc "grid", "Run grid commands"
+      subcommand "grid", Grid
+
+      desc "machine", "Run machine commands"
+      subcommand "machine", Machine
+
+      desc "syncer", "Run syncer commands"
+      subcommand "syncer", Syncer
+    end
+  end
+end
+
+SmartMachine::Commands::CLI.start(ARGV)

data/lib/smart_machine/configuration.rb

@@ -0,0 +1,79 @@
+require "active_support/core_ext/hash/keys"
+require "erb"
+
+module SmartMachine
+  class Configuration < SmartMachine::Base
+
+    def initialize
+    end
+
+    def config
+      @config ||= OpenStruct.new(grids: grids)
+    end
+
+    private
+
+    def grids
+      @grids ||= OpenStruct.new(elasticsearch: elasticsearch, minio: minio, mysql: mysql, prereceiver: prereceiver, redis: redis)
+    end
+
+    def elasticsearch
+      # Once the SmartMachine.config assignments in smart_machine.rb file has been removed, then this file exist condition can be removed to ensure that config/elasticsearch.yml always exists
+      if File.exist? "config/elasticsearch.yml"
+        deserialize(IO.binread("config/elasticsearch.yml")).deep_symbolize_keys
+      elsif File.exist? "#{File.expand_path('~')}/machine/config/elasticsearch.yml"
+        deserialize(IO.binread("#{File.expand_path('~')}/machine/config/elasticsearch.yml")).deep_symbolize_keys
+      else
+        {}
+      end
+    end
+
+    def minio
+      # Once the SmartMachine.config assignments in smart_machine.rb file has been removed, then this file exist condition can be removed to ensure that config/minio.yml always exists
+      if File.exist? "config/minio.yml"
+        deserialize(IO.binread("config/minio.yml")).deep_symbolize_keys
+      elsif File.exist? "#{File.expand_path('~')}/machine/config/minio.yml"
+        deserialize(IO.binread("#{File.expand_path('~')}/machine/config/minio.yml")).deep_symbolize_keys
+      else
+        {}
+      end
+    end
+
+    def mysql
+      # Once the SmartMachine.config assignments in smart_machine.rb file has been removed, then this file exist condition can be removed to ensure that config/mysql.yml always exists
+      if File.exist? "config/mysql.yml"
+        deserialize(IO.binread("config/mysql.yml")).deep_symbolize_keys
+      elsif File.exist? "#{File.expand_path('~')}/machine/config/mysql.yml"
+        deserialize(IO.binread("#{File.expand_path('~')}/machine/config/mysql.yml")).deep_symbolize_keys
+      else
+        {}
+      end
+    end
+
+    def prereceiver
+      # Once the SmartMachine.config assignments in smart_machine.rb file has been removed, then this file exist condition can be removed to ensure that config/prereceiver.yml always exists
+      if File.exist? "config/prereceiver.yml"
+        deserialize(IO.binread("config/prereceiver.yml")).deep_symbolize_keys
+      elsif File.exist? "#{File.expand_path('~')}/machine/config/prereceiver.yml" # To ensure file exists when inside the pre-receive hook of prereceiver.
+        deserialize(IO.binread("#{File.expand_path('~')}/machine/config/prereceiver.yml")).deep_symbolize_keys
+      else
+        {}
+      end
+    end
+
+    def redis
+      # Once the SmartMachine.config assignments in smart_machine.rb file has been removed, then this file exist condition can be removed to ensure that config/redis.yml always exists
+      if File.exist? "config/redis.yml"
+        deserialize(IO.binread("config/redis.yml")).deep_symbolize_keys
+      elsif File.exist? "#{File.expand_path('~')}/machine/config/redis.yml"
+        deserialize(IO.binread("#{File.expand_path('~')}/machine/config/redis.yml")).deep_symbolize_keys
+      else
+        {}
+      end
+    end
+
+    def deserialize(config)
+      YAML.load(ERB.new(config).result).presence || {}
+    end
+  end
+end

data/lib/smart_machine/credentials.rb

@@ -3,124 +3,122 @@ require "tmpdir"
 require "active_support/message_encryptor"
 require "active_support/core_ext/hash/keys"
 
-# The main SmartMachine Credentials driver
 module SmartMachine
-	class Credentials < SmartMachine::Base
+  class Credentials < SmartMachine::Base
 
-		CIPHER = "aes-256-gcm"
+    CIPHER = "aes-256-gcm"
 
-		def initialize
-		end
+    def initialize
+    end
 
-		def create
-			write_key
-			write credentials_template
-		end
+    def create
+      write_key
+      write credentials_template
+    end
 
-		def edit
-			content_path = Pathname.new "config/credentials.yml.enc"
-			tmp_file = "#{Process.pid}.#{content_path.basename.to_s.chomp('.enc')}"
-			tmp_path = Pathname.new File.join(Dir.tmpdir, tmp_file)
-			contents = read
-			tmp_path.binwrite contents
+    def edit
+      content_path = Pathname.new "config/credentials.yml.enc"
+      tmp_file = "#{Process.pid}.#{content_path.basename.to_s.chomp('.enc')}"
+      tmp_path = Pathname.new File.join(Dir.tmpdir, tmp_file)
+      contents = read
+      tmp_path.binwrite contents
 
-			system("#{ENV['EDITOR']} #{tmp_path}")
+      system("#{ENV['EDITOR']} #{tmp_path}")
 
-			updated_contents = tmp_path.binread
+      updated_contents = tmp_path.binread
 
-			if updated_contents != contents
-				write(updated_contents)
-				puts "File encrypted and saved."
-			else
-				puts "File contents were not changed."
-			end
-		ensure
-			FileUtils.rm(tmp_path) if tmp_path&.exist?
-		end
+      if updated_contents != contents
+        write(updated_contents)
+        puts "File encrypted and saved."
+      else
+        puts "File contents were not changed."
+      end
+    ensure
+      FileUtils.rm(tmp_path) if tmp_path&.exist?
+    end
 
-		def read_key
-			read_env_key || read_key_file || handle_missing_key
-		end
+    def read_key
+      read_env_key || read_key_file || handle_missing_key
+    end
 
-		def config
-			@config ||= deserialize(read).deep_symbolize_keys
-		end
+    def config
+      @config ||= deserialize(read).deep_symbolize_keys
+    end
 
-		private
+    private
 
-		def credentials_template
+    def credentials_template
 			<<~YAML
 			  machine:
 			    name: #{SecureRandom.hex(8)}
-			    address: 122.122.122.122
+			    address: 127.0.0.1
 			    port: 22
 			    root_password: #{SecureRandom.hex(16)}
 			    username: #{SecureRandom.hex(8)}
 			    password: #{SecureRandom.hex(16)}
-
-  			  minio:
-  			    name: #{SecureRandom.hex(8)}
+			  minioone:
   			    access_key: #{SecureRandom.hex(8)}
   			    secret_key: #{SecureRandom.hex(16)}
-  			    browser: on
-  			    worm: off
-
-			  mysql:
-			    port: 3306
+			  mysqlone:
 			    root_password: #{SecureRandom.hex(16)}
 			    username: #{SecureRandom.hex(8)}
 			    password: #{SecureRandom.hex(16)}
 			    database_name: #{SecureRandom.hex(8)}
-
-  			  elasticsearch:
-  			    port: 9200
+			  redisone:
+			    password: #{SecureRandom.hex(16)}
 			YAML
-		end
-
-		def read
-			decrypt IO.binread "config/credentials.yml.enc"
-		end
-
-		def write(contents)
-			IO.binwrite "config/credentials.yml.enc.tmp", encrypt(contents)
-			FileUtils.mv "config/credentials.yml.enc.tmp", "config/credentials.yml.enc"
-		end
-
-		def encrypt(contents)
-			encryptor.encrypt_and_sign contents
-		end
-
-		def decrypt(contents)
-			encryptor.decrypt_and_verify contents
-		end
-		
-		def encryptor
-			@encryptor ||= ActiveSupport::MessageEncryptor.new([ read_key ].pack("H*"), cipher: CIPHER)
-		end
-
-		def create_key
-			SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
-		end
-
-		def write_key
-			IO.binwrite "config/master.key.tmp", create_key
-			FileUtils.mv "config/master.key.tmp", "config/master.key"
-		end
-
-		def read_env_key
-			ENV['SMARTMACHINE_MASTER_KEY']
-		end
-
-		def read_key_file
-			IO.binread("config/master.key").strip if File.file?("config/master.key")
-		end
-
-		def handle_missing_key
-			raise "Missing SMARTMACHINE_MASTER_KEY. Please add SMARTMACHINE_MASTER_KEY to your environment."
-		end
-
-		def deserialize(config)
-			YAML.load(config).presence || {}
-		end
-	end
-end
+    end
+
+    def read
+      if File.exist? "config/credentials.yml.enc"
+        decrypt IO.binread "config/credentials.yml.enc"
+      elsif File.exist? "#{File.expand_path('~')}/machine/config/credentials.yml.enc"
+        decrypt IO.binread "#{File.expand_path('~')}/machine/config/credentials.yml.enc"
+      else
+        raise "Could not find credentials file."
+      end
+    end
+
+    def write(contents)
+      IO.binwrite "config/credentials.yml.enc.tmp", encrypt(contents)
+      FileUtils.mv "config/credentials.yml.enc.tmp", "config/credentials.yml.enc"
+    end
+
+    def encrypt(contents)
+      encryptor.encrypt_and_sign contents
+    end
+
+    def decrypt(contents)
+      encryptor.decrypt_and_verify contents
+    end
+
+    def encryptor
+      @encryptor ||= ActiveSupport::MessageEncryptor.new([ read_key ].pack("H*"), cipher: CIPHER)
+    end
+
+    def create_key
+      SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
+    end
+
+    def write_key
+      IO.binwrite "config/master.key.tmp", create_key
+      FileUtils.mv "config/master.key.tmp", "config/master.key"
+    end
+
+    def read_env_key
+      ENV['SMARTMACHINE_MASTER_KEY']
+    end
+
+    def read_key_file
+      IO.binread("config/master.key").strip if File.file?("config/master.key")
+    end
+
+    def handle_missing_key
+      raise "Missing SMARTMACHINE_MASTER_KEY. Please add SMARTMACHINE_MASTER_KEY to your environment."
+    end
+
+    def deserialize(config)
+      YAML.load(config).presence || {}
+    end
+  end
+end