neptuno 1.0.0

data/lib/neptuno/docker/up.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Docker
+    # Build docker container for Neptuno project
+    class Up < Neptuno::CLI::Base
+      desc 'Docker: bring up docker containers for current project'
+
+      option :all, type: :boolean, default: false, desc: 'Run on all services'
+      option :log, type: :boolean, default: false, desc: 'Show service log (only first service)'
+      argument :services, type: :array, required: false, desc: 'Optional list of services'
+
+      def call(services: [], **options)
+        dd = config.fetch('docker_delimiter') || '-'
+        command_services_to('come up', all: options.fetch(:all), services_as_args: services) do |services, project|
+          system("cd #{neptuno_path} && docker compose up -d #{services.join(' ')}")
+          system("cd #{neptuno_path} && docker logs -f #{project}#{dd}#{services.first}#{dd}1") if options.fetch(:log)
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/environment/config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Environment
+    # Build docker container for Neptuno project
+    class Config < Neptuno::CLI::Base
+      desc 'Environment: Configure local or remote'
+
+      argument :services, type: :array, required: false, desc: 'Optional list of services'
+
+      def call(services: [], **_options)
+        command_services_to('print', services_as_args: services) do |services|
+          services.each do |service|
+            puts service
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/environment/update.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Environment
+    # Build docker container for Neptuno project
+    class Update < Neptuno::CLI::Base
+      desc 'Environment: Update all environment files'
+
+      def call
+        env_path = "#{neptuno_path}/environments/"
+        services.each do |service|
+          service_env_path = env_path + service
+          if File.exist?("#{service_env_path}/key") && File.exist?("#{service_env_path}/secrets.gpg")
+            system("cd #{service_env_path} && gpg --pinentry-mode loopback --passphrase-file key secrets.gpg")
+            system("cd #{service_env_path} && cat default secrets > local_env")
+            system("cd #{service_env_path} && rm secrets")
+          else
+            system("cd #{service_env_path} && ln -sf default local_env")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/git/pull.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Git
+    # Pull all submodule changes
+    class Pull < Neptuno::CLI::Base
+      desc 'Git: pull all submodule changes'
+
+      def call(services: [], **_options)
+        system('git submodule foreach git pull')
+      end
+    end
+  end
+end

data/lib/neptuno/git/stash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Git
+    # Stash all submodule changes
+    class Stash < Neptuno::CLI::Base
+      desc 'Git: stash all submodule changes'
+
+      def call(services: [], **_options)
+        system('git submodule foreach git stash')
+      end
+    end
+  end
+end

data/lib/neptuno/k8s/attach.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module K8s
+    class Attach < Neptuno::CLI::Base
+      include ::Neptuno::TTY::Config
+      desc 'K8s: Attach to a container with k8s'
+
+      option :context, type: :string, default: 'int', desc: 'K8s context to run in'
+      option :namespace, type: :string, default: 'thrillshare', desc: 'K8s namespace to run in'
+      option :dependent, type: :string, desc: 'Dependent service'
+      option :pr, type: :integer, desc: "PR's Github ID"
+
+      def call(**options)
+        command_service_to('attach with k8s', service_as_args: options[:args]&.first) do |service, _project|
+          deployment = "deploy/#{options[:dependent] || service}"
+          deployment += "-#{service}-#{options[:pr]}" unless options[:pr].nil?
+
+          context = options[:context]
+          context = 'qa' unless options[:pr].nil?
+
+          system("kubectl config use-context #{context} > /dev/null 2>&1")
+          puts "Attaching to #{deployment} in the #{options[:namespace]} namespace using the #{context} context"
+          system("kubectl exec #{deployment} -n #{options[:namespace]} --stdin --tty -- /bin/sh")
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/overmind/connect.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Overmind
+    # Build docker container for Neptuno project
+    class Connect < Neptuno::CLI::Base
+      include ::Neptuno::TTY::Config
+      desc 'Overmind: Connect to processes inside docker containers'
+
+      option :force, type: :boolean, default: false, desc: 'Try to connect disrigarding container status'
+      option :all, type: :boolean, default: false, desc: 'Run on all services'
+      option :up, type: :boolean, default: false, desc: 'Try to start containers before connecting'
+      option :tmux, type: :boolean, default: false, desc: 'Connect to services using Tmux'
+      option :tmux_sessions, type: :boolean, default: false, desc: 'Connect to services using Tmux'
+      argument :services, type: :array, required: false, desc: 'Optional list of services'
+
+      def call(services: [], **options)
+        dd = config.fetch('docker_delimiter') || '-'
+        multi_spinner = ::TTY::Spinner::Multi.new('[:spinner] Services')
+        spinners = {}
+        count = 0
+        command_services_to('connect to procs', all: options.fetch(:all), services_as_args: services) do |services|
+          system("cd #{neptuno_path} && docker-compose up -d #{services.join(' ')}") if options.fetch(:up)
+          running_services = ::Neptuno::CLI::List.new.running_services.first.keys
+          running_services.sort.each do |service|
+            spinners[service] ||= multi_spinner.register("[:spinner] :state #{service}")
+            spinners[service].update(state: '-          ')
+            spinners[service].auto_spin
+          end
+          loop do
+            ps = `cd #{neptuno_path} && docker-compose ps`.split("\n").compact.select { |x| x.match(/^\s*#{project}/) }
+
+            running_services.sort.each do |service|
+              service_ps = ps.find { |s| s.include?(project.to_s) && s.include?("#{dd}#{service}#{dd}") }
+
+              status = :dead if service_ps.to_s.include?('exited')
+              status = :starting if service_ps.to_s.include?('starting')
+              status = :unhealthy if service_ps.to_s.include?('(unhealthy')
+              status = :healthy if service_ps.to_s.include?('(healthy')
+              status = :force if options.fetch(:force)
+
+              case status
+              when :force
+                spinners[service].success
+                `cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N  > /dev/null 2>&`
+              when :dead
+                spinners[service].update(state: 'dead       ')
+                spinners[service].error
+              when :starting
+                spinners[service].update(state: 'starting   ')
+              when :unhealthy
+                spinners[service].update(state: 'unhealthy  ')
+                spinners[service].error if spinners[service].instance_variable_get(:@state) == :spinning && count > 50
+              when :healthy
+                spinners[service].update(state: 'ready      ')
+                spinners[service].success
+              else
+                spinners[service].update(state: 'down       ')
+                spinners[service].error
+              end
+            end
+            break if spinners.values.map { |s| s.instance_variable_get(:@state) }.uniq.all?(:stopped)
+
+            count += 1
+            sleep(5)
+          end
+          spinner = ::TTY::Spinner.new('Neptuno: Connecting[:spinner]', format: :dots)
+          spinner.auto_spin
+
+          healthy_services = spinners.select { |_k, v| v.instance_variable_get(:@succeeded) == :success }.keys
+          spinner.stop
+          if config.fetch('procfile_manager') == 'tmux'
+            healthy_services.each do |service|
+              pid = spawn("cd #{neptuno_path} && tmuxinator start neptuno_#{service} #{service} -n #{service}",
+                          3 => '/dev/null')
+              Process.detach(pid)
+              puts "Neptuno started tmux session for: #{service}"
+            end
+          else
+            spinners.select { |_k, v| v.instance_variable_get(:@succeeded) == :success }.each_key do |service|
+              system("cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N  > /dev/null 2>&1")
+            end
+            sleep(5)
+            spinner.stop
+            if options.fetch(:tmux)
+              system("cd #{neptuno_path} && tmuxinator start neptuno #{healthy_services.join(' ')}")
+            else
+              begin
+                system("cd #{neptuno_path}/procfiles/#{services.first} && overmind connect shell", exception: true)
+              rescue RuntimeError
+                puts 'sry'
+                system("cd #{neptuno_path} && docker compose exec #{service} kill -9 -1")
+                system("cd #{neptuno_path}/procfiles/#{service} && rm .overmind.sock  > /dev/null 2>&1")
+                system("cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N  > /dev/null 2>&1")
+                retry
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/overmind/start.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Overmind
+    # Build docker container for Neptuno project
+    class Start < Neptuno::CLI::Base
+      include ::Neptuno::TTY::Config
+      desc 'Overmind: Start processes inside docker containers'
+
+      option :force, type: :boolean, default: false, desc: 'Try to start disrigarding container status'
+      option :all, type: :boolean, default: false, desc: 'Run on all services'
+      option :up, type: :boolean, default: false, desc: 'Try to start containers before connecting'
+      argument :services, type: :array, required: false, desc: 'Optional list of services'
+
+      def call(services: [], **options)
+        dd = config.fetch('docker_delimiter') || '-'
+        multi_spinner = ::TTY::Spinner::Multi.new('[:spinner] Services')
+        spinners = {}
+        count = 0
+        command_services_to('connect to procs', all: options.fetch(:all), services_as_args: services) do |services|
+          system("cd #{neptuno_path} && docker compose up -d #{services.join(' ')}") if options.fetch(:up)
+          running_services = ::Neptuno::CLI::List.new.running_services.first.keys
+          running_services.sort.each do |service|
+            spinners[service] ||= multi_spinner.register("[:spinner] :state #{service}")
+            spinners[service].update(state: '-          ')
+            spinners[service].auto_spin
+          end
+          loop do
+            ps = `cd #{neptuno_path} && docker compose ps`.split("\n").compact.select { |x| x.match(/^\s*#{project}/) }
+
+            running_services.sort.each do |service|
+              service_ps = ps.find { |s| s.include?(project.to_s) && s.include?("#{dd}#{service}#{dd}") }
+
+              status = :dead if service_ps.to_s.include?('exited')
+              status = :starting if service_ps.to_s.include?('starting')
+              status = :unhealthy if service_ps.to_s.include?('(unhealthy')
+              status = :healthy if service_ps.to_s.include?('(healthy')
+              status = :force if options.fetch(:force)
+
+              case status
+              when :force
+                spinners[service].success
+                `cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N  > /dev/null 2>&1`
+              when :dead
+                spinners[service].update(state: 'dead       ')
+                spinners[service].error
+              when :starting
+                spinners[service].update(state: 'starting   ')
+              when :unhealthy
+                spinners[service].update(state: 'unhealthy  ')
+                spinners[service].error if spinners[service].instance_variable_get(:@state) == :spinning && count > 50
+              when :healthy
+                spinners[service].update(state: 'ready      ')
+                spinners[service].success
+                `cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N  > /dev/null 2>&1`
+              else
+                spinners[service].update(state: 'down       ')
+                spinners[service].error
+              end
+            end
+            break if spinners.values.map { |s| s.instance_variable_get(:@state) }.uniq.all?(:stopped)
+
+            count += 1
+            sleep(5)
+          end
+          spinner = ::TTY::Spinner.new('Neptuno: Starting[:spinner]', format: :dots)
+          spinner.auto_spin
+
+          spinner.stop
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/overmind/stop.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Overmind
+    # Build docker container for Neptuno project
+    class Stop < Neptuno::CLI::Base
+      desc 'Overmind: Stop processes inside docker containers'
+
+      option :all, type: :boolean, default: false, desc: 'Run on all services'
+      argument :services, type: :array, required: false, desc: 'Optional list of services'
+
+      def call(services: [], **options)
+        command_services_to('stop procs', all: options.fetch(:all), services_as_args: services) do |services|
+          services.each do |service|
+            system("cd #{neptuno_path} && docker compose exec #{service} kill -9 -1")
+            system("cd #{neptuno_path}/procfiles/#{service} && rm .overmind.sock  > /dev/null 2>&1")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/services/add.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Services
+    # Add project to neptuno
+    class Add < Neptuno::CLI::Base
+      include TTY::Prompt
+      include TTY::Config
+      include TTY::File
+
+      desc 'Add a Neptuno service with Git'
+
+      def call(**)
+        name = prompt.ask('? Service name:')
+        add_name_to_config(name)
+        repo = prompt.ask('? Git repo:')
+        clone_into_folder(repo, name)
+        add_dockerfile(name)
+        add_procfile(name)
+        add_environment(name)
+        add_service_to_dc(name)
+      end
+
+      def add_name_to_config(name)
+        config.append(name, to: :services) unless config.fetch(:services).include? name
+        config.write(force: true)
+      end
+
+      def clone_into_folder(repo, name)
+        if repo.nil?
+          command.run("mkdir #{neptuno_path}/services/#{name}")
+        else
+          command.run("cd #{neptuno_path} && git submodule add #{repo} ./services/#{name}")
+        end
+      end
+
+      def add_dockerfile(name)
+        file.create_file("#{neptuno_path}/dockerfiles/#{name}/Dockerfile")
+        file.create_file("#{neptuno_path}/dockerfiles/#{name}/entrypoint.sh")
+      end
+
+      def add_procfile(name)
+        file.create_file("#{neptuno_path}/procfiles/#{name}/Procfile")
+      end
+
+      def add_environment(name)
+        file.create_file("#{neptuno_path}/environments/#{name}/default")
+      end
+
+      def add_service_to_dc(name)
+        puts(<<~EOT)
+          #---------------------------------------------------------------
+          # Registered #{name} as a service. You can now add it to the docker-compose.yml:
+          #---------------------------------------------------------------
+
+          version: '3'
+          services:
+            ##########################
+            # #{name}
+            ##########################
+            #{name}:
+              stdin_open: true
+              tty: true
+              command: ash
+              build:#{' '}
+                context: .
+                dockerfile: ./dockerfiles/#{name}/Dockerfile
+              env_file:#{' '}
+                - ./environments/#{name}/default
+              # volumes:#{' '}
+              #   -
+              # ports:#{' '}
+              #   -
+              # depends_on:#{' '}
+              #   -
+
+          #---------------------------------------------------------------
+          # Next steps
+          #---------------------------------------------------------------
+
+          Add the service's Dockerfile at ./dockerfiles/#{name}/Dockerfile
+          Add the service's Environments at ./environments/#{name}/default
+          Add the service's Procfile at ./procfiles/#{name}/Procfile
+        EOT
+      end
+    end
+  end
+end

data/lib/neptuno/services/destroy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Services
+    # Add project to neptuno
+    class Destroy < Neptuno::CLI::Base
+      desc 'Remove a Neptuno service'
+
+      def call(**)
+        puts destroy
+      end
+    end
+  end
+end

data/lib/neptuno/services/list.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Services
+    # Add project to neptuno
+    class List < Neptuno::CLI::Base
+      desc 'List Neptuno projects'
+
+      def call(**); end
+    end
+  end
+end

data/lib/neptuno/services/update.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module Services
+    # Update project to to latest GH master/main
+    class Update < Neptuno::CLI::Base
+      desc 'Stashes changes and pulls latest from main/master'
+
+      option :all, type: :boolean, default: false, desc: 'Run on all services'
+      option :main, type: :boolean, default: false,
+                    desc: "Keep service on main/master after pull. Uncommited changes are stashed as 'neptuno_stash'"
+      argument :services, type: :array, required: false, desc: 'Optional list of services'
+
+      def call(services: [], **options)
+        command_services_to('update', all: options.fetch(:all), services_as_args: services) do |services|
+          services.each do |service|
+            puts "---Updating #{service}---"
+            current_branch = `git branch --show-current`
+            puts current_branch
+            system("cd #{neptuno_path}/services/#{service}  2>/dev/null && git stash save -u -q neptuno_stash")
+            `cd #{neptuno_path}/services/#{service} 2>/dev/null && git checkout main 2>/dev/null`
+            `cd #{neptuno_path}/services/#{service} 2>/dev/null && git checkout master 2>/dev/null`
+            system("cd #{neptuno_path}/services/#{service} 2>/dev/null && git pull")
+            unless options.fetch(:main)
+              stash_id = `git stash list`.lines.find { |str| str =~ /neptuno_stash/ }&.split(':')&.first
+              `cd #{neptuno_path}/services/#{service} 2>/dev/null && git checkout #{current_branch} 2>/dev/null`
+              if stash_id
+                puts 'Applying stashed changes'
+                system("cd #{neptuno_path}/services/#{service} 2>/dev/null && git stash pop -q #{stash_id}")
+              end
+            end
+            puts ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/templates/docker-compose.yml

@@ -0,0 +1,7 @@
+version: '3'
+services:
+  alpine:
+    image: alpine
+    tty: true
+    stdin_open: true
+    command: ash

data/lib/neptuno/tty/command.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module TTY
+    # Wrapper class for TTY gem
+    module Command
+      include TTY::Config
+      TTY = ::TTY::Command.new(printer: :null)
+      TTYP = ::TTY::Command.new(printer: :pretty)
+
+      def command
+        TTY
+      end
+
+      def command_p
+        TTYP
+      end
+
+      def neptuno_command(command)
+        `cd #{neptuno_path} && #{command}`
+      end
+    end
+  end
+end

data/lib/neptuno/tty/config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module TTY
+    # Wrapper class for TTY gem
+    module Config
+      TTY = ::TTY::Config.new
+      TTY.filename = 'neptuno'
+
+      ABORT_MESSAGE = 'fatal: there are no registered services. Add one with: neptuno services add'
+
+      def config
+        TTY
+      end
+
+      def services
+        s = config.fetch('services')
+        abort ABORT_MESSAGE if s.count.zero?
+        s.sort
+      end
+
+      def configured_services
+        config.fetch('configured_services')
+      end
+    end
+  end
+end

data/lib/neptuno/tty/file.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module TTY
+    # Wrapper class for TTY gem
+    module File
+      TTY = ::TTY::File
+      ABORT_MESSAGE = 'fatal: not a Neptuno repository (or any of the parent directories)'
+
+      def file
+        TTY
+      end
+
+      # define path helpers
+      def project
+        neptuno_path.split('/').last
+      end
+
+      def in_service?
+        Dir.pwd.include?("#{neptuno_path}/services/")
+      end
+
+      def service
+        ENV['PWD'].match(%r{services/([^/]*)})&.captures&.first
+      end
+
+      def neptuno_path
+        return @base_path if @base_path
+
+        pwd = Dir.pwd
+        loop do
+          return pwd if pwd == ''
+          return @base_path = pwd if Dir.children(pwd).include?('neptuno.yml')
+
+          pwd = pwd.split('/')[0..-2].join('/')
+        end
+      end
+    end
+  end
+end

data/lib/neptuno/tty/prompt.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module TTY
+    # Wrapper class for TTY gem
+    module Prompt
+      TTY = ::TTY::Prompt.new
+
+      def prompt
+        TTY
+      end
+    end
+  end
+end

data/lib/neptuno/tty/which.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neptuno
+  module TTY
+    # Wrapper class for TTY gem
+    module Which
+      TTY = ::TTY::Which
+
+      def which(args)
+        TTY.which(args)
+      end
+    end
+  end
+end

data/lib/neptuno/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Neptuno
+  VERSION = '1.0.0'
+end

data/lib/neptuno.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'tty-config'
+require 'tty-command'
+require 'tty-which'
+require 'tty-file'
+require 'tty-spinner'
+require 'hirb'
+require 'dotiw'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect('neptuno' => 'Neptuno')
+loader.inflector.inflect('cli' => 'CLI')
+loader.inflector.inflect('tty' => 'TTY')
+loader.setup
+
+module Neptuno
+end