lex-onboard 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74c904f4f9278bbb31dfeacf303ec989e91d85cc0947935d85c1119f7ab98200
-  data.tar.gz: 6e1f50f1fa14308abfdd4e4bf41233c993dafeaac6ef11afdb3f6d602bbc78a4
+  metadata.gz: 945d2252b6dec50ef82d5ff441ef39099c146b0a1dbd7300e1eb9a10238f9bc3
+  data.tar.gz: 4213f845c3c1211175427ab0f98381c11832640da13556fbc30dcf7264723867
 SHA512:
-  metadata.gz: 29b4496a85b322f17349909214054ef4c9ab5e55ac857d01a88d1dbc234e219e84f17e5b8252edf7501dd80321bd5e842e5b6ca21b35d44cdae667c768bd2106
-  data.tar.gz: 65fbd780e1adf5c12c8eaee6cfd712f9052c9e3eadc23e21c9f064c3a25abfe2614f9fb3dd9b845ac444522b0026b9e6e6eaa4331b3aadb3f2f0331fd94373f4
+  metadata.gz: 966c8d189ef9f44a6c77c44b65eedcf582f4ac9dfca8dd2a6fc61223d48d29c7057aad5633095e08ad5d1bd94d5a3657dc225b5c13110ef36ae247eca3937946
+  data.tar.gz: 63bece2311db70ff269547be69007c130d302f5c415e1792aeea6e55ef905d77108bd1a2af880ae4b5bda5e67c7b92e1595c5662a0e64ea0eb6c17facd0b46f6

data/lib/legion/extensions/onboard/runners/provision.rb

@@ -5,55 +5,125 @@ module Legion
     module Onboard
       module Runners
         module Provision
+          include Validator
+
+          ROLLBACK_ACTIONS = {
+            vault_namespace: ->(client, askid) { client.delete_namespace(name: askid) },
+            consul_partition: ->(client, askid) { client.delete_partition(name: askid) },
+            tfe_project: ->(client, askid) { client.delete_project(name: askid) }
+          }.freeze
+
           def provision(askid:, tfe_organization: 'terraform.uhg.com', requester_slack_webhook: nil, **)
+            validation = validate_askid(askid: askid)
+            return { status: 'rejected', askid: askid, reason: validation[:reason] } unless validation[:valid]
+
+            conflicts = check_conflicts(askid: askid)
+            unless conflicts[:conflicts].empty?
+              return { status: 'rejected', askid: askid, reason: "conflict in: #{conflicts[:conflicts].join(', ')}" }
+            end
+
+            completed_steps = []
             steps = []
 
-            steps << run_step('vault_namespace') { create_vault_namespace(name: askid) }
-            steps << run_step('consul_partition') { create_consul_partition(name: askid) }
-            steps << run_step('tfe_project') { create_tfe_project(name: askid, organization: tfe_organization) }
-            steps << run_step('notify') { notify_requester(askid: askid, webhook: requester_slack_webhook) }
+            %i[vault_namespace consul_partition tfe_project].each do |step_name|
+              result = run_step(step_name, askid: askid, tfe_organization: tfe_organization)
+              steps << result
+
+              if result[:status] == 'error'
+                rollback_results = rollback(completed_steps, askid: askid)
+                return { status: 'failed', askid: askid, steps: steps, rollback: rollback_results }
+              end
 
-            failed = steps.any? { |s| s[:status] == 'error' }
+              completed_steps << step_name if result[:status] == 'completed'
+            end
 
-            {
-              status: failed ? 'failed' : 'completed',
-              askid: askid,
-              steps: steps
-            }
+            notify_requester(askid: askid, webhook: requester_slack_webhook) if requester_slack_webhook
+            { status: 'completed', askid: askid, steps: steps, rollback: [] }
           end
 
           private
 
-          def run_step(name)
-            yield
-            { name: name, status: 'ok' }
+          def run_step(step_name, askid:, tfe_organization:)
+            case step_name
+            when :vault_namespace then vault_namespace(askid: askid)
+            when :consul_partition then consul_partition(askid: askid)
+            when :tfe_project then tfe_project(askid: askid, organization: tfe_organization)
+            end
+          end
+
+          def rollback(completed_steps, askid:)
+            completed_steps.reverse.map do |step_name|
+              action = ROLLBACK_ACTIONS[step_name]
+              next unless action
+
+              action.call(client_for_step(step_name), askid)
+              { step: step_name, status: 'rolled_back' }
+            rescue StandardError => e
+              { step: step_name, status: 'rollback_failed', error: e.message }
+            end.compact
+          end
+
+          def client_for_step(step_name)
+            case step_name
+            when :vault_namespace then vault_client
+            when :consul_partition then consul_client
+            when :tfe_project then tfe_client
+            end
+          end
+
+          def vault_namespace(askid:)
+            unless defined?(Legion::Extensions::Vault::Client)
+              return { step: :vault_namespace, status: 'skipped', reason: 'vault unavailable' }
+            end
+            return { step: :vault_namespace, status: 'skipped', reason: 'already exists' } if vault_exists?(askid)
+
+            vault_client.create_namespace(name: askid)
+            { step: :vault_namespace, status: 'completed', askid: askid }
           rescue StandardError => e
-            { name: name, status: 'error', error: e.message }
+            { step: :vault_namespace, status: 'error', error: e.message }
           end
 
-          def create_vault_namespace(name:)
-            return { result: false } unless defined?(Legion::Extensions::Vault::Client)
+          def consul_partition(askid:)
+            unless defined?(Legion::Extensions::Consul::Client)
+              return { step: :consul_partition, status: 'skipped', reason: 'consul unavailable' }
+            end
+            return { step: :consul_partition, status: 'skipped', reason: 'already exists' } if consul_exists?(askid)
 
-            Legion::Extensions::Vault::Client.new.create_namespace(name: name)
+            consul_client.create_partition(name: askid)
+            { step: :consul_partition, status: 'completed', askid: askid }
+          rescue StandardError => e
+            { step: :consul_partition, status: 'error', error: e.message }
           end
 
-          def create_consul_partition(name:)
-            return { result: false } unless defined?(Legion::Extensions::Consul::Client)
+          def tfe_project(askid:, organization:)
+            unless defined?(Legion::Extensions::Tfe::Client)
+              return { step: :tfe_project, status: 'skipped', reason: 'tfe unavailable' }
+            end
+            return { step: :tfe_project, status: 'skipped', reason: 'already exists' } if tfe_exists?(askid)
 
-            Legion::Extensions::Consul::Client.new.create_partition(name: name)
+            tfe_client.create_project(organization: organization, name: askid)
+            { step: :tfe_project, status: 'completed', askid: askid }
+          rescue StandardError => e
+            { step: :tfe_project, status: 'error', error: e.message }
+          end
+
+          def vault_client
+            Legion::Extensions::Vault::Client.new
           end
 
-          def create_tfe_project(name:, organization:)
-            return { result: false } unless defined?(Legion::Extensions::Tfe::Client)
+          def consul_client
+            Legion::Extensions::Consul::Client.new
+          end
 
-            Legion::Extensions::Tfe::Client.new.create_project(organization: organization, name: name)
+          def tfe_client
+            Legion::Extensions::Tfe::Client.new
           end
 
           def notify_requester(askid:, webhook: nil)
             return true unless webhook && defined?(Legion::Extensions::Slack::Client)
 
             Legion::Extensions::Slack::Client.new.send_webhook(
-              webhook: webhook, text: "Onboarding complete for #{askid}"
+              webhook: webhook, message: "Onboarding complete for #{askid}"
             )
           rescue StandardError
             true

data/lib/legion/extensions/onboard/runners/validator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Onboard
+      module Runners
+        module Validator
+          ASKID_PATTERN = /\A[a-z0-9]([a-z0-9-]*[a-z0-9])?\z/
+          MAX_ASKID_LENGTH = 63
+
+          def validate_askid(askid:)
+            return { valid: false, reason: 'askid is empty' } if askid.nil? || askid.empty?
+            return { valid: false, reason: "askid exceeds #{MAX_ASKID_LENGTH} characters" } if askid.length > MAX_ASKID_LENGTH
+
+            unless askid.match?(ASKID_PATTERN)
+              return { valid: false,
+                       reason: 'askid format invalid — must be lowercase alphanumeric with hyphens' }
+            end
+
+            { valid: true }
+          end
+
+          def check_conflicts(askid:)
+            conflicts = []
+            conflicts << :vault if vault_exists?(askid)
+            conflicts << :consul if consul_exists?(askid)
+            conflicts << :tfe if tfe_exists?(askid)
+
+            { conflicts: conflicts, askid: askid }
+          end
+
+          private
+
+          def vault_exists?(askid)
+            return false unless defined?(Legion::Extensions::Vault::Client)
+
+            Legion::Extensions::Vault::Client.new.list_namespaces[:namespaces]&.include?(askid)
+          rescue StandardError
+            false
+          end
+
+          def consul_exists?(askid)
+            return false unless defined?(Legion::Extensions::Consul::Client)
+
+            Legion::Extensions::Consul::Client.new.list_partitions[:partitions]&.any? { |p| p[:name] == askid }
+          rescue StandardError
+            false
+          end
+
+          def tfe_exists?(askid)
+            return false unless defined?(Legion::Extensions::Tfe::Client)
+
+            Legion::Extensions::Tfe::Client.new.list_projects[:projects]&.any? { |p| p[:name] == askid }
+          rescue StandardError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/onboard/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Onboard
-      VERSION = '0.1.1'
+      VERSION = '0.2.0'
     end
   end
 end

data/lib/legion/extensions/onboard.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'onboard/version'
+require_relative 'onboard/runners/validator'
 require_relative 'onboard/runners/provision'
 
 module Legion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-onboard
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Esity
@@ -118,6 +118,7 @@ files:
 - lib/legion/extensions/onboard.rb
 - lib/legion/extensions/onboard/actors/provision.rb
 - lib/legion/extensions/onboard/runners/provision.rb
+- lib/legion/extensions/onboard/runners/validator.rb
 - lib/legion/extensions/onboard/version.rb
 homepage: https://github.com/LegionIO
 licenses: