harbr 0.1.41 → 0.1.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 961d2fcd8bbf17593359f10c94fedb0dea4ee66ddd63847e5aa4b22d26b7e2ba
-  data.tar.gz: 8bd0be2d101562f224e8101556514eea70fc9cf31b74b6bd838df08a79059736
+  metadata.gz: b4a81834b6e281138d670063f16e6ce3aef3ba2a4c611126c5769f7a800c6a43
+  data.tar.gz: '09c9cb7ba2a44b1d61282c05c63d5cf6a9ea96711d063805268b15fbee0b4569'
 SHA512:
-  metadata.gz: 714bd9940f1cfdacfa242567adbe006470c919c50c31669f03f32c60a28a9ef0b45bfdb8834605ddfcea6157716ba0486f5686183584f098788a8bafe2602db6
-  data.tar.gz: 7e800f4514d06701ced3a12a359458201be7ad2b5c51c2cf5603e9a34a6eef1ec18f34e5b616bd14cddaaca0c5f672df3150739da120b2c82ed1fc3641822cd2
+  metadata.gz: 11e9eb1bc37ab2095afcac4509521c414d38c7b40fbe0215d9e035d0bfda830999b9c210576cf8dea4903ad35e13bb8062eeb6c5eb2cdeb4f9a7b4fa6e4008c9
+  data.tar.gz: 1ecaed7982e06159ef3a16956754fc8d5c677c4ffa40548852a5685a36ab68971d22f317455fa27d01794118d14be762e6ea8caf832dbc73160e86f3ff81ca17

data/exe/harbr

@@ -92,10 +92,10 @@ class HarbrCLI < Thor
           Dir.exist?("/var/harbr/containers/#{container}/versions/#{version}/config/manifest.yml")
         end
 
-        Harbr::Job.perform_async(container, version)
+        Harbr::Job.perform_async(container, versio,"live")
       else
         sleep 3
-        Harbr::Next::Job.perform_async(container, version)
+        Harbr::Job.perform_async(container, version,"next")
         puts "deploy next version #{version} of #{container}"        
       end
       

data/lib/harbr/job.rb

@@ -1,4 +1,9 @@
+require "yaml"
+require "ostruct"
+require "sucker_punch"
 require "harbr"
+require "tomlrb"
+
 module Harbr
   class Job
     include SuckerPunch::Job
@@ -10,13 +15,7 @@ module Harbr
     def create_traefik_config(containers)
       config = {
         "http" => {
-          "routers" => {
-            "traefik-dashboard" => {
-              "rule" => "Host(`traefik.harbr.zero2one.ee`)",
-              "service" => "api@internal",
-              "tls" => {}  # Enable TLS for the dashboard
-            }
-          },
+          "routers" => {},
           "services" => {}
         }
       }
@@ -25,18 +24,16 @@ module Harbr
         container.ip = "127.0.0.1"
         name = container.name.tr(".", "-")
 
-        # Create the router with TLS enabled and specific format
         router_key = "#{name}-router-secure"
         config["http"]["routers"][router_key] = {
           "rule" => "Host(`#{container.host_header}`)",
           "service" => "#{name}-service",
           "entryPoints" => ["https"],
           "tls" => {
-            "certResolver" => "myresolver"  # Use a custom certificate resolver
+            "certResolver" => "myresolver"
           }
         }
 
-        # Create the service
         config["http"]["services"]["#{name}-service"] = {
           "loadBalancer" => {
             "servers" => [{"url" => "http://#{container.ip}:#{container.port}"}]
@@ -44,7 +41,6 @@ module Harbr
         }
       end
 
-      # Write the configuration to a TOML file
       File.write("/etc/traefik/harbr.toml", TomlRB.dump(config))
       puts "Traefik configuration written to /etc/traefik/harbr.toml"
     end
@@ -64,99 +60,130 @@ module Harbr
         container.port = port
         containers.update(container)
       end
+
       containers.all
     end
 
-    module Runit
-      class Run
-        def initialize(container, port)
-          @container_name = container
-          @port = port
-        end
+    def write_to_file(path, contents)
+      File.write(path, contents)
+    end
 
-        def to_s
-          <<~SCRIPT
-            #!/bin/sh
-            exec 2>&1    
-            cd /var/harbr/containers/#{@container_name}/current
-            exec ./exe/run #{@port} live 
-          SCRIPT
-        end
+    def load_manifest(container, version)
+      manifest_path = "/var/harbr/containers/#{container}/versions/#{version}/config/manifest.yml"
+      raise "Manifest not found at #{manifest_path}" unless File.exist?(manifest_path)
 
-        def link
-          "ln -s /etc/sv/harbr/#{@container_name} /etc/service/#{@container_name}"
-        end
+      manifest_data = YAML.load_file(manifest_path)
+      OpenStruct.new(manifest_data)
+    end
+
+    def perform(name, version, env)
+      Harbr.notifiable(name, version) do
+        manifest = load_manifest(name, version)
+        port = `port assign #{env}.#{manifest.port}`.strip
+
+        current_path = "/var/harbr/containers/#{name}/versions/#{version}"
+        check_dir_exists(current_path)
+
+        process_container(name, version, port, env, manifest)
       end
+    end
 
-      class Finish
-        def initialize(port)
-          @port = port
-        end
+    private
 
-        def to_s
-          <<~SCRIPT
-            #!/bin/sh
-            sleep 3
-            `lsof -i :#{@port} | awk 'NR!=1 {print $2}' | xargs kill`
-          SCRIPT
+    def check_dir_exists(path)
+      sleep_times = [1, 3, 5, 8, 23]
+      begin
+        sleep_times.each do |time|
+          return if Dir.exist?(path)
+          sleep(time)
         end
+        raise "Directory not found: #{path}"
+      rescue => e
+        puts "Error: #{e.message}"
       end
+    end
 
-      class Log
-        def initialize(container)
-          @container_name = container
-        end
+    def process_container(name, version, port, env, manifest)
+      env_path = "/var/harbr/containers/#{name}/#{env}"
+      system "sv stop #{env}.#{name}" if env == 'next'
+
+      bundle_install_if_needed(env_path)
+      create_runit_scripts(name, port, env)
+      link_directories(name, version, env)
+      sync_live_data_if_next(name) if env == 'next'
 
-        def to_s
-          <<~SCRIPT
-            #!/bin/sh
-            exec svlogd -tt /var/log/harbr/#{@container_name}
-          SCRIPT
+      containers = collate_containers("#{env}.#{name}", "#{env}.#{manifest.host}", port)
+      create_traefik_config(containers)
+      puts "harbr: #{version} of #{name} in #{env} environment"
+    end
+
+    def bundle_install_if_needed(path)
+      Dir.chdir(path) do
+        if File.exist?("Gemfile")
+          `bundle config set --local path 'vendor/bundle'`
+          system "bundle install"
         end
       end
     end
 
-    def write_to_file(path, contents)
-      File.write(path, contents)
+    def create_runit_scripts(name, port, env)
+      run_script = Runit::Script.new(name, port, env).run_script
+      finish_script = Runit::Script.new(name, port, env).finish_script
+      log_script = Runit::Script.new(name, port, env).log_script
+
+      write_to_file "/etc/sv/harbr/#{name}/#{env}/run", run_script
+      write_to_file "/etc/sv/harbr/#{name}/#{env}/finish", finish_script
+      write_to_file "/etc/sv/harbr/#{name}/#{env}/log/run", log_script
+
+      `chmod +x /etc/sv/harbr/#{name}/#{env}/run`
+      `chmod +x /etc/sv/harbr/#{name}/#{env}/log/run`
+      `chmod +x /etc/sv/harbr/#{name}/#{env}/finish`
     end
 
-    def load_manifest(container, version)
-      manifest_path = "/var/harbr/containers/#{container}/versions/#{version}/config/manifest.yml"
-      raise "Manifest not found at #{manifest_path}" unless File.exist?(manifest_path)
-      manifest_data = YAML.load_file(manifest_path)
-      OpenStruct.new(manifest_data)
+    def link_directories(name, version, env)
+      `rm -f /etc/service/#{env}.#{name}`
+      `rm -f /var/harbr/containers/#{name}/#{env}`
+
+      `ln -sf /var/harbr/containers/#{name}/versions/#{version} /var/harbr/containers/#{name}/#{env}`
+      `ln -sf /etc/sv/harbr/#{name}/#{env} /etc/service/#{env}.#{name}`
     end
 
-    def perform(name, version)
-      Harbr.notifiable(name, version) do
-        Dir.chdir "/var/harbr/containers/#{name}/versions/#{version}" do
-          manifest = load_manifest(name, version)
-          port = `port assign #{manifest.port}`.strip
-          system "sv stop #{name}" if File.exist?("/etc/service/#{name}")
-          if File.exist?("Gemfile")
-            `bundle config set --local path 'vendor/bundle'`
-            system "bundle install"
-          end
-
-          `mkdir -p /etc/sv/harbr/#{name}`
-          `mkdir -p /etc/sv/harbr/#{name}/log`
-          `mkdir -p /var/log/harbr/#{name}`
-
-          write_to_file "/etc/sv/harbr/#{name}/run", Runit::Run.new(name, port).to_s
-          write_to_file "/etc/sv/harbr/#{name}/finish", Runit::Finish.new(port).to_s
-          write_to_file "/etc/sv/harbr/#{name}/log/run", Runit::Log.new(name).to_s
-
-          `chmod +x /etc/sv/harbr/#{name}/run`
-          `chmod +x /etc/sv/harbr/#{name}/log/run`
-          `chmod +x /etc/sv/harbr/#{name}/finish`
-
-          system "ln -sf /var/harbr/containers/#{name}/versions/#{version} /var/harbr/containers/#{name}/current"
-          system "ln -sf /etc/sv/harbr/#{name} /etc/service/#{name}"
-
-          containers = collate_containers(name, manifest.host, port)
-          create_traefik_config(containers)
-          puts "process #{version} of #{name}"
-        end
+    def sync_live_data_if_next(name)
+      `rsync -av /var/dddr/#{name}/live /var/dddr/#{name}/next`
+      puts "sync live data to next"
+    end
+  end
+
+  module Runit
+    class Script
+      def initialize(container, port, env)
+        @container_name = container
+        @port = port
+        @env = env
+      end
+
+      def run_script
+        <<~SCRIPT
+          #!/bin/sh
+          exec 2>&1
+          cd /var/harbr/containers/#{@container_name}/#{@env}
+          exec ./exe/run #{@port} #{@env}
+        SCRIPT
+      end
+
+      def finish_script
+        <<~SCRIPT
+          #!/bin/sh
+          sleep 3
+          `lsof -i :#{@port} | awk 'NR!=1 {print $2}' | xargs kill`
+        SCRIPT
+      end
+
+      def log_script
+        <<~SCRIPT
+          #!/bin/sh
+          exec svlogd -tt /var/log/harbr/#{@container_name}/#{@env}/
+        SCRIPT
       end
     end
   end

data/lib/harbr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Harbr
-  VERSION = "0.1.41"
+  VERSION = "0.1.42"
 end

data/lib/harbr.rb

@@ -11,7 +11,6 @@ require "resend"
 require_relative "harbr/version"
 require_relative "harbr/container"
 require_relative "harbr/job"
-require_relative "harbr/next/job"
 
 # Harbr module for managing containers, jobs, ports, and 2s
 module Harbr

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: harbr
 version: !ruby/object:Gem::Version
-  version: 0.1.41
+  version: 0.1.42
 platform: ruby
 authors:
 - Delaney Kuldvee Burke
@@ -149,7 +149,6 @@ files:
 - lib/harbr.rb
 - lib/harbr/container.rb
 - lib/harbr/job.rb
-- lib/harbr/next/job.rb
 - lib/harbr/version.rb
 - sig/harbr.rbs
 - vendor/bundle/ruby/3.2.0/bin/bundle

data/lib/harbr/next/job.rb

@@ -1,249 +0,0 @@
-require "yaml"
-require "ostruct"
-require "sucker_punch"
-
-require "harbr"
-module Harbr
-  module Next
-    class Job
-      include SuckerPunch::Job
-
-
-      def check
-        sleep_times = [1, 3, 5, 8, 23]
-        begin
-          result = yield if block_given?
-          unless result
-            sleep_times.each do |time|
-              result = yield if block_given?
-              break if result
-              sleep(time)
-            end
-          end
-        rescue => e
-          puts "Error: #{e.message}"
-        end
-      end
-
-      def get_container_name(path)
-        File.basename(path)
-      end
-
-      def create_traefik_config(containers)
-        config = {
-          "http" => {
-            "routers" => {
-              "traefik-dashboard" => {
-                "rule" => "Host(`traefik.harbr.zero2one.ee`)",
-                "service" => "api@internal",
-                "tls" => {}  # Enable TLS for the dashboard
-              }
-            },
-            "services" => {}
-          }
-        }
-
-        containers.each do |container|
-          container.ip = "127.0.0.1"
-          name = container.name.tr(".", "-")
-
-          # Create the router with TLS enabled and specific format
-          router_key = "#{name}-router-secure"
-          config["http"]["routers"][router_key] = {
-            "rule" => "Host(`#{container.host_header}`)",
-            "service" => "#{name}-service",
-            "entryPoints" => ["https"],
-            "tls" => {
-              "certResolver" => "myresolver"  # Use a custom certificate resolver
-            }
-          }
-
-          # Create the service
-          config["http"]["services"]["#{name}-service"] = {
-            "loadBalancer" => {
-              "servers" => [{"url" => "http://#{container.ip}:#{container.port}"}]
-            }
-          }
-        end
-
-        # Write the configuration to a TOML file
-        File.write("/etc/traefik/harbr.toml", TomlRB.dump(config))
-        puts "Traefik configuration written to /etc/traefik/harbr.toml"
-      end
-
-      def collate_containers(name, host, port)
-        containers = Harbr::Container::Repository.new
-        container = containers.find_by_header(host)
-
-        if container.nil?
-          container = Harbr::Container.new
-          container.name = name
-          container.host_header = host
-          container.ip = "127.0.0.1"
-          container.port = port
-          containers.create(container)
-        else
-          container.port = port
-          containers.update(container)
-        end
-        containers.all
-      end
-
-      module Runit
-        class Run
-          def initialize(container, port)
-            @container_name = container
-            @port = port
-          end
-
-          def to_s
-            <<~SCRIPT
-              #!/bin/sh
-              exec 2>&1
-              cd /var/harbr/#{@container_name}/current
-              exec ./exe/run #{@port} live
-            SCRIPT
-          end
-
-          def link
-            "ln -s /etc/sv/harbr/#{@container_name} /etc/service/#{@container_name}"
-          end
-        end
-
-        class Finish
-          def initialize(port)
-            @port = port
-          end
-
-          def to_s
-            <<~SCRIPT
-              #!/bin/sh
-              sleep 3
-              `lsof -i :#{@port} | awk 'NR!=1 {print $2}' | xargs kill`
-            SCRIPT
-          end
-        end
-
-        class Log
-          def initialize(container, port)
-            @container_name = container
-          end
-
-          def to_s
-            <<~SCRIPT
-              #!/bin/sh
-              exec svlogd -tt /var/log/harbr/#{@container_name}/next/
-            SCRIPT
-          end
-        end
-
-        module Next
-          class Run
-            def initialize(container, port)
-              @container_name = container
-              @port = port
-            end
-
-            def to_s
-              <<~SCRIPT
-                #!/bin/sh
-                exec 2>&1
-                cd /var/harbr/containers/#{@container_name}/next
-                exec ./exe/run #{@port} next
-              SCRIPT
-            end
-          end
-
-          class Log
-            def initialize(container)
-              @container_name = container
-            end
-
-            def to_s
-              <<~SCRIPT
-                #!/bin/sh
-                exec svlogd -tt /var/log/harbr/#{@container_name}/next/
-              SCRIPT
-            end
-          end
-        end
-      end
-
-      def write_to_file(path, contents)
-        File.write(path, contents)
-      end
-
-      def load_manifest(container, version)
-        manifest_path = "/var/harbr/containers/#{container}/versions/#{version}/config/manifest.yml"
-        raise "Manifest not found at #{manifest_path}" unless File.exist?(manifest_path)
-        manifest_data = YAML.load_file(manifest_path)
-        OpenStruct.new(manifest_data)
-      end
-
-      def check
-        sleep_times = [1, 3, 5, 8, 23]
-        begin
-          result = yield if block_given?
-          unless result
-            sleep_times.each do |time|
-              result = yield if block_given?
-              break if result
-              sleep(time)
-            end
-          end
-        rescue => e
-          puts "Error: #{e.message}"
-        end
-      end
-
-      def perform(name, version)
-        Harbr.notifiable(name, version) do
-          manifest = load_manifest(name, version)
-          current_path = "/var/harbr/containers/#{name}/versions/#{version}"
-
-          port = `port assign next.#{manifest.port}`.strip
-          
-          check do
-            puts "Waiting for container #{current_path} 5to be available..."
-            Dir.exist?(current_path)
-          end
-
-          Dir.chdir current_path do
-            system "sv stop next.#{name}"
-            if File.exist?("Gemfile")
-              `bundle config set --local path 'vendor/bundle'`
-              system "bundle install"
-            end
-
-            `mkdir -p /etc/sv/harbr/#{name}/next`
-            `mkdir -p /etc/sv/harbr/#{name}/next/log`
-            `mkdir -p /var/log/harbr/#{name}/next/log`
-
-            write_to_file "/etc/sv/harbr/#{name}/next/run", Runit::Next::Run.new(name, port).to_s
-            write_to_file "/etc/sv/harbr/#{name}/next/finish", Runit::Finish.new(port).to_s
-            write_to_file "/etc/sv/harbr/#{name}/next/log/run", Runit::Next::Log.new(name).to_s
-
-            `chmod +x /etc/sv/harbr/#{name}/next/run`
-            `chmod +x /etc/sv/harbr/#{name}/next/log/run`
-            `chmod +x /etc/sv/harbr/#{name}/next/finish`
-
-            system "rm /etc/service/next.#{name}"
-            system "rm /var/harbr/containers/#{name}/next"
-
-            system "ln -sf /var/harbr/containers/#{name}/versions/#{version} /var/harbr/containers/#{name}/next"
-            system "ln -sf /etc/sv/harbr/#{name}/next /etc/service/next.#{name}"
-
-            `rsync -av /var/dddr/#{name}/live  /var/dddr/#{name}/next`
-            puts "sync live data to next"
-
-            system "sv restart next.#{name}"
-          end
-
-          containers = collate_containers("next.#{name}", "next.#{manifest.host}", port)
-          create_traefik_config(containers)
-          puts "harbr: #{version} of #{name} into next environment"
-        end
-      end
-    end
-  end
-end