lbhrr 1.0.27 → 2.32.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9316b3555eea12d2403c4b53f2294a09652458267b803938f725667b27b1ac4
-  data.tar.gz: aecf3fa3443f1ee16c92e59ae8936631e4e6d489194edad83fdfe316240c40ae
+  metadata.gz: 3f63fcc372df8525489ddf02ca8a023112a031ae24b5306614500022e556ccc8
+  data.tar.gz: a94d96eb246401e944fa044950f4e128dbb4cf16bc45e508f274e6879f88d2cc
 SHA512:
-  metadata.gz: 032ad826d862ae97d42e9ab573ce72ff00d985c3492931513b3de411e431ed08e5a6e0ea7e63d555c85c0d338b13c78907c584835ef9e9ed961f7141682a03e3
-  data.tar.gz: 6be6169070b182d3f54d254c81aa53391f49bee00d45e3d9a0c6fca6b08e0299c84ae714635793366dbfe93b4a5703ccf78271fe1450de66cd84b84a041ded21
+  metadata.gz: cec7337f7de060c7b98749195f9b2fe137735ffc88933077f8172c046b1e4867ab3cb76ffa9646de1a14dce3cb3b96469b824eaa94d53d6f35c06dde18921751
+  data.tar.gz: 4f62371636aadfb7d53168e1f4631b028c53e73291040c365b2b16fd459ef0270dc5d123af4445d0ed7487381c21bce79ba1d420f8d10b2d6b85e725736976bb

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/exe/lbhrr

@@ -1,175 +1,243 @@
 #!/usr/bin/env ruby
+
+require "fileutils"
+require "logger"
+require "erb"
+require "open3"
+require "io/console"
 require_relative "../lib/lbhrr"
 
 class LbhrrCLI < Thor
+  include Thor::Actions
+
+  # Error handling
+  def self.exit_on_failure?
+    true
+  end
+
   no_commands do
+    require 'net/http'
+    require 'uri'
 
-    def manifest?
-      File.exist? File.join(Dir.pwd, "config","manifest.yml")
+    def fibonacci(n)
+      [21,34,55][n]
     end
 
-    def package
-      # Load configuration
-      config = load_configuration
-      host = config["host"]
-      user = config["user"]
-      port = config["port"]
-      version = config["version"].to_i
-      raise "Configuration error: Host, User, or Version missing" unless host && port && user && version > 0
-
-      # Check for a git repository
-      unless `git rev-parse --is-inside-work-tree > /dev/null 2>&1`
-        raise "No Git repository found in the current directory"
-      end
+    def ok(url,grace: 0)
+      retries = 2
+      sleep(grace)
+      (0..retries).each do |i|
+        uri = URI(url)
+        response = Net::HTTP.get_response(uri)
+
+        if response.is_a?(Net::HTTPSuccess)
+          yield if block_given?
+          break
+        else
+          puts "Response was not 200, it was #{response.code}., check logs gor website"
+        end
 
-      # Delete vendor directory if it exists
-      vendor_path = File.join(Dir.pwd, "vendor")
-      FileUtils.rm_rf(vendor_path) if Dir.exist?(vendor_path)
-      `bundle config set --local path 'vendor/bundle'`
-      system "bundle install" or raise "Bundle install failed"
-      # Check if the repository is clean
-      puts "Git repository is dirty, committing changes..."
-      system("git add .") or raise "Failed to add changes to Git"
-      system("git commit -m 'packaged #{version}'") or raise "Failed to commit changes to Git"
-      puts "Packaging completed successfully."
+        delay = fibonacci(i)
+        sleep(delay)
 
+
+      end
     end
 
-    def amend_last_commit(new_message)
-      # Ensure we are in a git repository
-      system("git rev-parse --git-dir > /dev/null 2>&1") or raise "Not a git repository"
+    # Example usage:
+    def with_error_handling
+      # Ensure the ~/.lbhrr directory exists
+      log_dir = File.expand_path("~/.lbhrr")
+      FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+
+      # Setup logger
+      logger = Logger.new("#{log_dir}/error.log")
+
+      begin
+        yield
+      rescue Interrupt
+        #logger.error("Operation interrupted by Ctrl+C")
+      rescue => e
+        logger.error("Error occurred: #{e.class}: #{e.message}")
+        raise
+      end
+    end
 
-      # Amend the last commit with the new message
-      system("git commit --amend -m \"#{new_message}\"") or raise "Failed to amend the last commit"
+    def increment_version(version, focus = :minor)
+      major, minor, patch = version.split(".").map(&:to_i)
+
+      case focus
+      when :major
+        major += 1
+        # Reset minor and patch to 0 when major version increments
+        minor = 0
+        patch = 0
+      when :minor
+        minor += 1
+        # Reset patch to 0 when minor version increments
+        patch = 0
+      when :patch
+        patch += 1
+      else
+        raise ArgumentError, "Invalid focus: #{focus}. Valid options are :major, :minor, :patch."
+      end
 
-      puts "Successfully amended the last commit."
-    rescue => e
-      puts "Error during commit amend: #{e.message}"
+      "#{major}.#{minor}.#{patch}"
     end
 
-    def create_gitignore
-      gitignore_path = File.join(Dir.pwd, ".gitignore")
-      return if File.exist?(gitignore_path)
-
-      gitignore_content = '
-        # Ignore bundler config and installed gems.
-        /.bundle
-        # Ignore all logfiles and tempfiles.
-        /log/*
-        /tmp/*
-        !/log/.keep
-        !/tmp/.keep
-
-        # Ignore other unneeded files.
-        *.pid
-        *.swap
-        *.gem
-        *.rbc
-        .DS_Store
-        .idea
-        .byebug_history
-        '
-
-      File.write(gitignore_path, gitignore_content.strip)
-      puts ".gitignore created for Rack project."
-    rescue => e
-      puts "Error creating .gitignore: #{e.message}"
+    def progressing(name = "Task")
+      # Start the long-running task in a separate thread, yielding to the given block
+      task_thread = Thread.new do
+        yield if block_given? # Execute the block representing the long-running task
+      end
+
+      spinner = Enumerator.new do |e|
+        rectangles = ["[ ]","[=]", "[==]", "[===]", "[===]", "[==","[=]","[ ]"]
+        loop do
+          rectangles.each { |rect| e.yield rect }
+          rectangles.reverse.each { |rect| e.yield rect }
+        end
+      end
+
+      until task_thread.join(0.1)
+        print "#{name} is in progress..  \r#{spinner.next}"
+        $stdout.flush
+        sleep(0.1)
+      end
+
+      # Clear the progress line
+      print "#{name} is in progress.. #{spinner.peek}\r"
+      nil
     end
 
-    def deployed(local_manifest_path, version)
-      # Git add all changes
-      increment_version(local_manifest_path, version)
-      system("git add .") or raise "Failed to add changes to Git"
-      # Commit changes with a message
-      commit_message = "Deployed version #{version}"
-      amend_last_commit commit_message
-      # Create a Git tag for the version
-      tag_message = "Deployment for version #{version}"
-      system("git tag -a 'v#{version}' -m '#{tag_message}'") or raise "Failed to create Git tag"
-
-      puts "Deployment changes committed and tagged as v#{version}."
-    rescue => e
-      puts "Error during post-deployment process: #{e.message}"
+    def find_container_ip(container_name)
+      initial_backoff_intervals = [5, 8, 13, 21]
+      ip_backoff_intervals = [1, 2, 3, 5, 8]
+      ip_address = nil
+
+      # First, check if the container is running
+      container_running = false
+      initial_backoff_intervals.each do |interval|
+        output, status = Open3.capture2("lxc list -f csv | grep #{container_name}")
+        if status.success? && !output.empty? && output.split(",")[1].strip == "RUNNING"
+          container_running = true
+          break
+        end
+        sleep(interval)
+      end
+
+      # If container is running, look for the IP address
+      if container_running
+        ip_backoff_intervals.each do |interval|
+          output, status = Open3.capture2("lxc list -f csv | grep #{container_name}")
+          if status.success? && !output.empty?
+            data = output.split(",")
+            ip_address = data[2].split(" ").first
+            if !ip_address.nil? && !ip_address.empty?
+              yield(ip_address) if block_given?
+              break
+            end
+          end
+          sleep(interval)
+        end
+      end
+
+      ip_address
     end
 
-    def create_example_global_config
-      example_global_config = {
-        "user" => "root",
-        "host" => "harbr.zero2one.ee"
-      }
-      YAML.dump(example_global_config)
+    def clean_up(name = nil)
+      # Remove the build directory
+      if Dir.exist?("build")
+        FileUtils.rm_r("build")
+      end
+      # Remove gems on the container
+      `lxc exec #{name} -- rm -rf /var/gems/*`
     end
 
-    def create_run_file(type)
+    def modify_manifest
+      file_path = "config/manifest.yml"  # Update the path if necessary
+
+      # Read the YAML file
+      if File.exist?(file_path)
+        yaml_content = YAML.load_file(file_path)
 
-      service_content = <<-RUBY
-      #!/usr/bin/env ruby
-      require 'bundler/inline'
+        # Yield the hash to the block for modification
+        yield(yaml_content) if block_given?
 
-      gemfile do
-        source 'https://rubygems.org'
-        #gem 'kafkr', require: true
+        # Write the changes back to the YAML file
+        File.write(file_path, yaml_content.to_yaml)
+      else
+        puts "File not found: #{file_path}"
       end
+    end
 
-      puts 'Gems installed and loaded!'
+    def notify_terminal(message, title)
+      `terminal-notifier -message "#{message}" -title "#{title}" -contentImage "crane.png"`
+    end
 
-      loop do
-        puts 'ok!' 
-        sleep 1
-      end
+    def containerized?(name)
+      `lxc list -c n -f csv`.include? name
+    end
 
-      RUBY
+    def create_container(name, image = "panamax")
+      return if containerized? name
+      config = load_configuration
 
-      if type == "web"
-        run_file_path = File.join(Dir.pwd, "exe", "run")
-        web_run_file_content = "#!/bin/sh\n HARBR_ENV=$2 bundle exec puma -p $1"
-        exe_directory = File.join(Dir.pwd, "exe")
+      # Set default image if not specified
+      image = config["image"].nil? ? "panamax" : config["image"]
 
-        Dir.mkdir(exe_directory) unless Dir.exist?(exe_directory)
-        File.write(run_file_path, web_run_file_content)
-        File.chmod(0o755, run_file_path) # Set executable permission
-        puts "Created ./exe/run file."
-      end
+      `lxc launch #{image} #{name}` unless containerized? name
 
-      if type == "service"
-        run_file_path = File.join(Dir.pwd, "exe", "run")
-        service_run_file_content = "#!/bin/sh\n HARBR_ENV=$2 ruby service"
-        exe_directory = File.join(Dir.pwd, "exe")
-        
-        Dir.mkdir(exe_directory) unless Dir.exist?(exe_directory)
-        File.write(run_file_path, service_run_file_content)
-        File.chmod(0o755, run_file_path) # Set executable permission
-        puts "Created ./exe/run file."
-
-        File.write("service", service_content)
-        File.chmod(0o755, "service") # Set executable permission
-        puts "Created ./service file."
-        
+      find_container_ip(name) do |ip_address|
+        `harbr container add #{name} #{ip_address}`
+
+        if config["host"].nil?
+          `harbr host add #{name} 9292 #{name}.harbr.zero2one.ee`
+          `harbr host add #{name} 9393 next.#{name}.harbr.zero2one.ee`
+        else
+          `harbr host add #{name} 9292 #{config["host"]}`
+          `harbr host add #{name} 9393 next.#{config["host"]}`
+        end
+
+        `harbr commit`
       end
+    end
 
-      
+    # Method to process ERB templates and write to build directory
+    def process_template(template_path, target_path, binding)
+      content = ERB.new(File.read(template_path)).result(binding)
+      File.write(target_path, content)
+    end
+
+    def manifest?
+      File.exist? File.join(Dir.pwd, "config", "manifest.yml")
+    end
 
+    def commit(new_message)
+      # Ensure we are in a git repository
+      system("git rev-parse --git-dir > /dev/null 2>&1") or raise "Not a git repository"
+      # commit changes with the new message
+      `git commit -am '#{new_message}'`
     rescue => e
-      puts "Error creating ./exe/run file: #{e.message}"
+      puts "Error during commit amend: #{e.message}"
     end
 
-    def create_example_local_config(type)
-      example_local_config = {
-        "name" => File.basename(Dir.pwd),
-        "version" => "0",
-        "type" => type,
-        "port" => "#{File.basename(Dir.pwd)}.app",
-        "host" => "#{File.basename(Dir.pwd)}.harbr.zero2one.ee"
-      }
+    def amend_last_commit(new_message)
+      # Ensure we are in a git repository
+      system("git rev-parse --git-dir > /dev/null 2>&1") or raise "Not a git repository"
+
+      # Amend the last commit with the new message
+      system("git commit --amend -m \"#{new_message}\"") or raise "Failed to amend the last commit"
 
-      YAML.dump(example_local_config)
+      puts "Successfully amended the last commit."
+    rescue => e
+      puts "Error during commit amend: #{e.message}"
     end
 
     def load_configuration
       global_config_dir = File.expand_path("~/.config/harbr")
-      global_config_path = File.join(global_config_dir, "harbr.manifest.yml")
+      global_config_path = File.join(global_config_dir, "manifest.yml")
       local_config_path = File.join(Dir.pwd, "config", "manifest.yml")
-
       # Ensure global configuration exists
       unless File.exist?(global_config_path)
         FileUtils.mkdir_p(global_config_dir) unless Dir.exist?(global_config_dir)
@@ -185,195 +253,253 @@ class LbhrrCLI < Thor
 
       if File.exist? local_config_path
         local_config = YAML.load_file(local_config_path) || {}
-        global_config.merge(local_config)
+        global_config.merge!(local_config)
       end
 
       global_config
     end
 
-    def increment_version(manifest_path, current_version)
-      new_version = current_version + 1
+    desc "containerize", "Create a container for an app"
+    def containerize
+      config = load_configuration
+      name = config["name"]
+      image = config["image"]
+      if manifest?
+        create_container(name, image)
+      end
+    end
 
-      manifest = YAML.load_file(manifest_path)
-      manifest["version"] = new_version
-      File.write(manifest_path, manifest.to_yaml)
-      puts "Version incremented to #{new_version}"
+    desc "rollback", "rollback an application using the configuration from config/manifest.yml"
+    def rollback(name = nil)
+      with_error_handling do
+        progressing("Roll back") do
+          config = load_configuration
+          name = name.nil? ? config["name"] : name
+          rolled_back = config["rolledback"]
+
+          if config["rolledback"] == true
+            puts "No rollback available"
+          else
+            `lxc exec #{name} -- bash -c 'if [ -d /var/www/app/container/live ]; then rm /var/www/app/container/live; fi'`
+
+            `lxc exec #{name} -- mv /var/www/app/container/rollback /var/www/app/container/live`
+            `lxc exec #{name} -- bash -c 'if [ -d /var/www/app/container/rollback ]; then rm /var/www/app/container/rollback; fi'`
+            `lxc exec #{name} -- sv restart live`
+            modify_manifest do |config|
+              config["live"] = config["rollback"]
+              config["rolledback"] = true
+            end
+          end
+          commit("Rolled back #{name} to version #{config["rollback"]} on live")
+          ok("https://#{config['host']}/ok",grace: 15) do
+            notify_terminal("#{name} version #{config['rollback']} is up on live!", "Lbhhr")
+          end
+        end
+      end
     end
-  end
 
-  desc "init", "Initialize project with .gitignore"
-  method_option :type, type: :string, enum: ['web', 'service'], default: 'web', desc: "Specify the type of process"
-  def init
-    local_config_path = File.join(Dir.pwd, "config", "manifest.yml")
 
-    unless File.exist?(local_config_path)
-      FileUtils.mkdir_p(File.dirname(local_config_path)) unless Dir.exist?(File.dirname(local_config_path))
-      File.write(local_config_path, create_example_local_config(options[:type]))
-    end
-    # Load and merge configurations
-    local_config = YAML.load_file(local_config_path) || {}
-    create_gitignore
-    create_run_file(options[:type])
 
 
+    desc "assemble", "Build an application using the configuration from config/manifest.yml into a ruby gem"
+    def assemble(env = "next", version = nil)
+      config = load_configuration
+      name = config["name"]
+      image = config["image"]
+
+      containerize
 
-    # Include other initialization tasks if necessary
-  end
+      # Check if we're in the root directory
+      if manifest?
+        # Create the build directory if it doesn't exist
+        if Dir.exist?("build")
+          FileUtils.rm_r("build")
+        end
 
-  desc "containers", "list all containers"
-  def containers
-    config = load_configuration
-    host = config["host"]
-    user = config["user"]
-    puts `ssh #{user}@#{host} 'harbr containers'`
-  end
+        FileUtils.mkdir_p("build/src")
 
-  desc "drop", "Destroy an app and remove all traces"
-  def drop(name=nil)
-    config = load_configuration
-    host = config["host"]
-    user = config["user"]
+        # Copy all files and folders to the build directory
+        Dir.glob("*").each do |item|
+          next if item == "build" # Skip the build directory itself
+          next if item == ".git" # Skip the .git directory
+          next if item == "tmp" # Skip the config directory
 
-    if name.nil?
+          FileUtils.cp_r(item, "build/src/#{item}")
+        end
 
-      unless manifest?
-        puts "no manifest found!"
-        return
-      end
+        # Parameters for gemspec
+        gem_name = config["name"]
+        gem_version = version.nil? ? config["version"] : version
 
-      name = config["name"]
-    end
+        # Ensure the build directory exists
+        FileUtils.mkdir_p("build/lib")
 
-    puts "Destroying app: #{name}"
-    `ssh #{user}@#{host} 'harbr destroy #{name}'`
+        # Define the template files and their target locations
+        template_dir = File.expand_path(File.join(File.dirname(__FILE__), "../", "templates"))
 
-    puts "App #{name} has been successfully destroyed."
-  end
+        templates = {
+          "#{template_dir}/lib/panamax.rb.erb" => "build/lib/#{gem_name}.rb",
+          "#{template_dir}/lib/rubygems_plugin.rb.erb" => "build/lib/rubygems_plugin.rb",
+          "#{template_dir}/panamax.gemspec.erb" => "build/#{gem_name}.gemspec"
+        }
 
-  desc "lift", "Deploy an application using the configuration from config/manifest.yml to next"
-  def lift
-    if manifest?
-      
-      package
-      
+        # Process each template
+        templates.each do |template, target|
+          process_template(template, target, binding)
+        end
 
-      config = load_configuration
-      host = config["host"]
-      user = config["user"]
-      raise "Host configuration missing" unless host
-  
-      local_manifest_path = File.join(Dir.pwd, "config", "manifest.yml")
-      raise "Local manifest file not found at #{local_manifest_path}" unless File.exist?(local_manifest_path)
-  
-      local_config = YAML.load_file(local_manifest_path) || {}
-      version = local_config["version"].to_i
-      raise "Version not specified in manifest.yml" unless version
-  
-      basename = File.basename(Dir.pwd)
-      base_directory = "/var/harbr/containers/#{basename}"
-      versions_directory = "#{base_directory}/versions"
-      data_directory = "/var/dddr/#{basename}/"
-      destination_path = "#{versions_directory}/#{version}"
-      # Prepare the rsync exclude option using .gitignore
-      gitignore_path = File.join(Dir.pwd, ".gitignore")
-      exclude_option = File.exist?(gitignore_path) ? "--exclude='.git' --exclude-from='#{gitignore_path}'" : ""
-  
-  
-      # Check and create the versions directory on the server
-      `ssh #{user}@#{host} 'mkdir -p #{versions_directory}'`
-      `ssh #{user}@#{host} 'mkdir -p #{data_directory}'`
-  
-      # Rsync files to the new version directory, excluding files as per .gitignore
-      rsync_command = "rsync -avz #{exclude_option} ./ #{user}@#{host}:#{destination_path}"
-  
-      if `#{rsync_command}`
-        puts "Successfully deployed application version #{version} to #{host}"
-        deployed(local_manifest_path, version)
+        `cd build && gem build #{gem_name}.gemspec`
+        notify_terminal("Assembled #{name}", "Lbhhr")
       else
-        puts "Failed to deploy application version #{version} to #{host}"
+        puts "config/manifest file not found. Please ensure you are in the root directory of your project."
       end
-    
-    else 
-      puts "no manifest found!"
     end
 
   end
 
-  desc "logs", "Show logs for a container"
-  method_option :live, type: :boolean, aliases: "-l", desc: "Process in live mode"
-  method_option :next, type: :boolean, default: true, aliases: "-n", desc: "Process in next mode"
-  def logs(name=nil)
-    config = load_configuration
-    host = config["host"]
-    user = config["user"]
-
-    if name.nil?
-      unless manifest?
-        puts "no manifest found!"
-        return
-      end
-
-      container_name = config["name"]
 
-    else
-      container_name = name
+  desc "drop", "Destroy an app and remove all traces"
+  def drop(name = nil)
+    with_error_handling do
+      return unless yes?("Are you sure you want to drop this app? This action cannot be undone. (y/n)")
+
+      # Load configuration and retrieve the name if not provided
+      config = load_configuration unless name
+      name ||= config["name"]
+
+      progressing("Drop") do
+        if manifest?
+          # Check if the LXC container exists
+          if `lxc list`.include?(name)
+            # Commands to run if the container exists
+            `lxc delete #{name} --force`
+            `harbr container delete #{name}`
+            `harbr commit`
+          end
+        end
+      end
     end
+  end
 
-    if options[:live]
-      exec "ssh #{user}@#{host} 'harbr peek #{container_name} --live'"
-    else
-      exec "ssh #{user}@#{host} 'harbr peek #{container_name} --next'"
+  desc "logs", "Show logs for the container"
+  method_option :live, type: :boolean, aliases: "-l", desc: "Process in live mode"
+  def logs(name = nil)
+    with_error_handling do
+      config = load_configuration
+      name = config["name"]
+      if options[:live]
+        exec "lxc exec #{name} -- tail -f /var/log/container/live/current"
+      else
+        exec "lxc exec #{name} -- tail -f /var/log/container/next/current"
+      end
     end
   end
 
+  desc "hoist", "Deploy an application using the configuration from config/manifest.yml to next"
+  method_option :major, type: :boolean, aliases: "-ma", desc: "Increment major version"
+  method_option :msg, type: :boolean, aliases: "-msg", desc: "set the commit message"
+  method_option :minor, type: :boolean, aliases: "-mi", desc: "Increment minor version"
+  method_option :feature, type: :boolean, aliases: "-fea", desc: "Increment minor version"
+  method_option :fix, type: :boolean, aliases: "-f", desc: "Increment minor version"
+  method_option :release, type: :boolean, aliases: "-rel", desc: "Increment minor version"
+  method_option :patch, type: :boolean, aliases: "-pa", desc: "Increment minor version"
+  def hoist(name = nil)
+    with_error_handling do
+      config = load_configuration
 
-  desc "activity", "harbr logs "
-  def activity
-    container_name = File.basename(Dir.pwd)
-    config = load_configuration
-    host = config["host"]
-    user = config["user"]
-    exec "ssh #{user}@#{host} 'harbr logs'"
-  end
+      msg =nil
+      if options[:msg] 
+        msg = ask("commit massage: ")        
+      end
 
+      focus = nil
 
-  desc "hoist", "Deploy an application using the configuration from config/manifest.yml to live"
-  def hoist(name=nil)
-    config = load_configuration
-    host = config["host"]
-    user = config["user"]
+      focus = if options[:major] || options[:release]
+        "major"
+      elsif options[:minor] || options[:feature]
+        "minor"
+      elsif options[:patch] || options[:fix]
+        "patch"
+      else
+        "patch"
+      end
 
-    if name.nil?
-      unless manifest?
-        puts "no manifest found!"
-        return
+      version = increment_version(config["version"], focus.to_sym)
+
+      modify_manifest do |config|
+        config["version"] = version
+      end
+
+      progressing("Hoist") do
+        name = config["name"]
+        gem = "#{name}-#{version}.gem"
+        assemble "next", version
+        `lxc file push -rp build/#{gem} #{name}/var/gems/`
+        `lxc exec #{name} -- /root/.rbenv/shims/gem install /var/gems/#{gem} --no-document`
+        `lxc exec #{name} -- /root/.rbenv/shims/gem install /var/gems/#{gem} --no-document`
+        `lxc exec #{name} -- sv restart next`
+        `lxc exec #{name} -- sv restart next.ws`
+
+        modify_manifest do |config|
+          config["next"] = version
+        end
+
+        clean_up(name)
+
+        change = "RELEASE #{version}"
+        commit("#{change}\n\n#{msg}\n\n Hoisted #{name} version #{version}")
+
+        ok("https://next.#{config['host']}/ok",grace: 25) do
+          notify_terminal(" #{name} version #{version} is up on next!", "Lbhhr")
+        end
       end
-      name = config["name"]
     end
-    puts `ssh #{user}@#{host} 'harbr deploy #{name}'`
-  end 
-
-  desc "rollback", "rollback an application using the configuration from config/manifest.yml"
-  def rollback(name=nil)
-    
-    config = load_configuration
-    host = config["host"]
-    user = config["user"]
-
-    if name.nil?
-      unless manifest?
-        puts "no manifest found!"
-        return
+  end
+
+  desc "deploy", "Deploy an application using the configuration from config/manifest.yml to live"
+  def deploy(name = nil)
+    with_error_handling do
+      progressing("Deploy") do
+        config = load_configuration
+        name = name.nil? ? config["name"] : name
+        if config["next"].nil?
+          puts "No deploymnt available"
+        else
+          `lxc exec #{name} -- bash -c 'if [ -d /var/www/app/container/rollback ]; then rm -rf /var/www/app/container/rollback; fi'`
+          `lxc exec #{name} -- mv /var/www/app/container/live /var/www/app/container/rollback`
+          `lxc exec #{name} -- cp -r /var/www/app/container/next /var/www/app/container/live`
+          `lxc exec #{name} -- sv restart live`
+          `lxc exec #{name} -- sv restart ws`
+          modify_manifest do |config|
+            config["rollback"] = config["live"]
+            config["live"] = config["next"]
+            config["rolledback"] = false
+          end
+        end
+        commit("Deployed #{name} version #{config["live"]} to live")
+
+        ok("https://#{config['host']}/ok",grace: 15) do
+          notify_terminal(" #{name} version #{version} is up on live!", "Lbhhr")
+        end
+
       end
-      name = config["name"]
     end
-    puts `ssh #{user}@#{host} 'harbr rollback #{name}'`
-  end 
+  end
 
+  desc "version", "Display the version of Lbhrr"
+  def version
+    with_error_handling do
+      puts "lbhrr version #{Lbhrr::VERSION}"
+    end
+  end
 
-  def self.exit_on_failure?
-    true
+  desc "update", "Display the version of Lbhrr"
+  def update
+    with_error_handling do
+      `gem update lbhrr --conservative`
+    end
   end
+
 end
 
 LbhrrCLI.start(ARGV)

data/lib/.kafkr/acknowledged_messages.txt

@@ -0,0 +1 @@
+d2914e65-5f28-492f-9615-4f00fb29e437

data/lib/.kafkr/message_queue.txt

@@ -0,0 +1,5 @@
+L9l8YThIoCo83pL/5hZ5mrNTzRRCdUBuxXFYZxe5ZUSC0yeKn3tq11znnEaWXrWFiqaV62V8xhpHWBJo1B9gLA==
+5cmFh3rph/f/5dJr8MK8do6VyW44B5naEQg8iTHMaE1eXbLaS5lrZ9Co+VuybfQPkocGkPeYT4b55Ii7jzvDtw==
+vk/l4x1F9rcoJXdZoF3XIod68atgQZ9LeS3VRkZOmgQkA77FhqtZqXjPEo9/dVlz7CiS1P50jhg1SkdeFO5e5A==
+S7phDwdvAtXd4h6sjr/W+9uhGakSwObf3kAdyA30wQeajXY2d1oAygDXtr6bMEv5F5WfgbD0nz4vlPyO+e4Tuw==
+XanoLNMHjZM9LirLNYxnmFRZNDcWB7FqP1/MvE7Wxwa362mQi3wTwsvFsIE6c3yOv7WcokzgSMlmseD/BBX/Yg==

data/lib/lbhrr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lbhrr
-  VERSION = "1.0.27"
+  VERSION = "2.32.1"
 end

data/templates/lib/panamax.rb.erb

@@ -0,0 +1,4 @@
+class <%= gem_name.capitalize %>
+    DESTINATION = ENV.fetch("DEPLOYMENT_DESTINATION", "/var/www/app/container/")
+    ENV=ENV.fetch("DEPLOYMENT_ENV", "<%= env %>")        
+end

data/templates/lib/rubygems_plugin.rb.erb

@@ -0,0 +1,41 @@
+require 'prettyprint'
+
+Gem.pre_install do |installer|
+  if installer.spec.metadata.dig("container") == "panamax"
+    env = installer.spec.metadata.dig("env")
+    destination = File.join(installer.spec.metadata.dig("destination"), env) 
+    src = File.expand_path(File.join(File.dirname(__FILE__), '..', 'src'))
+    system("rm -rf #{destination}")    
+    puts "deploying #{installer.spec.name} to #{destination}"
+  end
+
+end
+
+Gem.post_install do |installer|
+  if installer.spec.metadata.dig("container") == "panamax"
+    env = installer.spec.metadata.dig("env")
+    destination = File.join(installer.spec.metadata.dig("destination"), env) 
+    src = File.expand_path(File.join(File.dirname(__FILE__), '..', 'src'))
+
+    
+    if env == "live"
+      puts "symlink files to #{destination}"
+      system("ln -sf #{src} #{destination}")
+    else
+      puts "copy files #{destination}"
+      system("cp -rf #{src} #{destination}") 
+      puts "copy uploads"
+      live = File.join(installer.spec.metadata.dig("destination"), "live") 
+      system("cp -rf #{live}/public/uploads/ #{destination}/public/uploads/")
+      puts "uploads synced"
+    end 
+
+    if File.exist?("#{destination}/bin/hoisted")
+      system("chmod +x #{destination}/bin/hoisted")
+      system("cd #{destination} && ./bin/hoisted")
+    end
+
+    puts "deployed #{installer.spec.name} to #{destination}"
+  end
+
+end

data/templates/panamax.gemspec.erb

@@ -0,0 +1,24 @@
+require 'rubygems'
+
+require_relative 'lib/<%= gem_name%>'
+Gem::Specification.new do |s|
+  s.name        = '<%= gem_name %>'
+  s.version     = '<%= gem_version %>'
+  s.authors     = ["Delaney Burke"]
+  s.email       = "delaney@zero2one.ee"
+  s.homepage    = "http://zero2one.ee/gems/<%= gem_name%>"
+  s.summary     = "<%= gem_name %> container desscripton"
+  s.description = "<%= gem_name %> container"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files = Dir['lib/**/*', 'src/**/*'].reject { |f| File.directory?(f) }
+  # s.add_dependency 'some-gem'
+  # s.extra_rdoc_files = ['README.md', 'LICENSE']
+  s.license = 'MIT'
+  s.metadata = {
+    "container" => "panamax",
+    "env" => <%= gem_name.capitalize %>::ENV,
+    "destination" => <%= gem_name.capitalize %>::DESTINATION
+  }
+end
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lbhrr
 version: !ruby/object:Gem::Version
-  version: 1.0.27
+  version: 2.32.1
 platform: ruby
 authors:
 - Delaney Kuldvee Burke
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-23 00:00:00.000000000 Z
+date: 2024-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -34,9 +34,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - ".gitignore"
-- ".gitlab-ci.yml"
 - ".rspec"
+- ".ruby-version"
 - ".standard.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -47,13 +48,18 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- config/manifest.yml
+- crane.png
 - exe/lbhrr
 - hero.png
 - lbhrr.gemspec
+- lib/.kafkr/acknowledged_messages.txt
+- lib/.kafkr/message_queue.txt
 - lib/lbhrr.rb
 - lib/lbhrr/version.rb
 - sig/lbhrr.rbs
+- templates/lib/panamax.rb.erb
+- templates/lib/rubygems_plugin.rb.erb
+- templates/panamax.gemspec.erb
 homepage: https://github.com/dekubu/lbhrr
 licenses:
 - MIT
@@ -76,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: A CLI tool for deploying and managing Rack applications.

data/.gitlab-ci.yml

@@ -1,10 +0,0 @@
-default:
-  image: ruby:3.2.2
-
-  before_script:
-    - gem install bundler -v 2.4.21
-    - bundle install
-
-example_job:
-  script:
-    - bundle exec rake

data/config/manifest.yml

@@ -1,5 +0,0 @@
----
-name: lbhrr
-version: 1
-port:
-host: lbhrr.harbr.zero2one.ee