neptuno 1.0.10 → 1.2.0

data/lib/neptuno/docker/services.rb

@@ -4,7 +4,7 @@ module Neptuno
   module Docker
     module Services
       include Neptuno::TTY::Config
-      require 'yaml'
+      require "yaml"
 
       def running_services
         running_services = `cd ~/.neptuno/projects/#{current_project} && docker compose ps | awk '{ print $3 }' | awk 'NR>1'`
@@ -13,7 +13,7 @@ module Neptuno
 
       def registered_services
         dc = YAML.load_file("#{neptuno_path}/docker-compose.yml")
-        dc['services'].keys
+        dc["services"].keys
       end
 
       def stopped_services

data/lib/neptuno/docker/up.rb

@@ -4,21 +4,16 @@ module Neptuno
   module Docker
     # Build docker container for Neptuno project
     class Up < Neptuno::CLI::Base
-      desc 'Docker: bring up docker containers for current project'
+      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'
+      option :all, type: :boolean, default: false, desc: "Run on all services"
+      option :wait, type: :boolean, default: true, desc: "Wait for services to be healthy"
+      argument :services, type: :array, required: false, desc: "Optional list of services"
 
       def call(services: [], **options)
-        command_services_to('come up', all: options.fetch(:all), services_as_args: services) do |services, project|
+        command_services_to("come up", all: options.fetch(:all), services_as_args: services) do |services, _project|
           make_service_files(services)
-          system("cd #{neptuno_path} && docker compose up -d #{services.join(' ')}")
-          success = system("cd #{neptuno_path} && docker logs -f #{project}_#{services.first}_1") if options.fetch(:log)
-          unless success
-            puts "Trying #{project}-#{services.first}-1"
-            system("cd #{neptuno_path} && docker logs -f #{project}-#{services.first}-1") if options.fetch(:log)
-          end
+          system("cd #{neptuno_path} && docker-compose up -d --wait #{services.join(" ")}")
         end
       end
     end

data/lib/neptuno/environment/config.rb

@@ -4,12 +4,12 @@ module Neptuno
   module Environment
     # Build docker container for Neptuno project
     class Config < Neptuno::CLI::Base
-      desc 'Environment: Configure local or remote'
+      desc "Environment: Configure local or remote"
 
-      argument :services, type: :array, required: false, desc: 'Optional list of services'
+      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|
+        command_services_to("print", services_as_args: services) do |services|
           services.each do |service|
             puts service
           end

data/lib/neptuno/environment/update.rb

@@ -4,7 +4,7 @@ module Neptuno
   module Environment
     # Build docker container for Neptuno project
     class Update < Neptuno::CLI::Base
-      desc 'Environment: Update all environment files'
+      desc "Environment: Update all environment files"
 
       def call
         env_path = "#{neptuno_path}/environments/"

data/lib/neptuno/git/pull.rb

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

data/lib/neptuno/git/stash.rb

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

data/lib/neptuno/k8s/attach.rb

@@ -4,20 +4,20 @@ module Neptuno
   module K8s
     class Attach < Neptuno::CLI::Base
       include ::Neptuno::TTY::Config
-      desc 'K8s: Attach to a container with k8s'
+      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 :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|
+        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?
+          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"

data/lib/neptuno/overmind/connect.rb

@@ -7,91 +7,40 @@ module Neptuno
       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 :up, type: :boolean, default: true, desc: 'Try to start containers before connecting'
+      option :start, type: :boolean, default: true, desc: 'Try to start processes on containers before connecting'
       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'
+      option :wait, type: :boolean, default: true, desc: 'Wait for all services to be healthy'
+      option :dependencies, type: :boolean, default: true, desc: 'Connect to service and its dependencies'
       argument :services, type: :array, required: false, desc: 'Optional list of services'
 
       def call(services: [], **options)
-        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 =~ /#{project}[-_]#{service}[-_]\d\s/ }
+          `neptuno up #{services.join(' ')}` if options.fetch(:up)
+          original_services = services
+          services = services_with_procs.intersection(get_dependants(services).concat(services).uniq).sort
 
-              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)
+          outside_tmux = `echo $TMUX`.strip.empty?
 
-              case status
-              when :force
-                spinners[service].success
-                `cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N #{auto_restart_procs.unshift("-r").join(" ") if auto_restart_procs.to_a.count > 0}  > /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
+          if config.fetch('procfile_manager') == 'tmux'
+            services.each do |service|
+              if /#{service}/.match?(`tmux ls`)
+                puts "Neptuno wil use existing Tmux session for: #{service}"
+                next
               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}",
+              pid = spawn("cd #{neptuno_path} && tmuxinator start neptuno_#{service} #{service}",
                           3 => '/dev/null')
               Process.detach(pid)
-              puts "Neptuno started tmux session for: #{service}"
+              puts "Neptuno started Tmux session for: #{service}" if `echo $TMUX`.strip.empty?
             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  #{auto_restart_procs.unshift("-r").join(" ") if auto_restart_procs.to_a.count > 0} > /dev/null 2>&1")
-            end
-            sleep(5)
-            spinner.stop
-            if options.fetch(:tmux)
-              system("cd #{neptuno_path} && tmuxinator start neptuno #{healthy_services.join(' ')}")
+            puts `neptuno start --no-up #{services.join(' ')}` if options.fetch(:start)
+            if outside_tmux
+              system("cd #{neptuno_path} && tmuxinator start neptuno #{services.join(' ')}")
             else
-              begin
-                system("cd #{neptuno_path}/procfiles/#{services.first} && overmind connect shell", exception: true)
-              rescue RuntimeError
-                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  #{auto_restart_procs.unshift("-r").join(" ") if auto_restart_procs.to_a.count > 0} > /dev/null 2>&1")
-                retry
-              end
+              puts "Connecting to #{original_services.first}"
+              system("cd #{neptuno_path}/procfiles/#{original_services.first} && overmind connect shell")
             end
           end
         end

data/lib/neptuno/overmind/start.rb

@@ -5,67 +5,33 @@ module Neptuno
     # Build docker container for Neptuno project
     class Start < Neptuno::CLI::Base
       include ::Neptuno::TTY::Config
-      desc 'Overmind: Start processes inside docker containers'
+      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'
+      option :all, type: :boolean, default: false, desc: "Run on all services"
+      option :up, type: :boolean, default: true, desc: "Try to start containers before connecting"
+      argument :services, type: :array, required: false, desc: "Optional list of services"
 
       def call(services: [], **options)
-        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 =~ /#{project}[-_]#{service}[-_]\d\s/ }
-
-              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
+        command_services_to("start procs", all: options.fetch(:all), services_as_args: services) do |services|
+          `neptuno up #{services.join(" ")}` if options.fetch(:up)
+
+          services = services_with_procs.intersection(get_dependants(services).concat(services).uniq).sort
+          puts "Starting processes on services: #{services.join(", ")}"
+
+          if config.fetch("procfile_manager") == "tmux"
+            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}" if `echo $TMUX`.strip.empty?
+            end
+          else
+            services.each do |service|
+              system("cd #{neptuno_path}/procfiles/#{service} && overmind start -D -N  #{if auto_restart_procs.to_a.size > 0
+                                                                                           ("-r " + auto_restart_procs.join(",") + " ")
+                                                                                         end} > /dev/null 2>&1")
             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

data/lib/neptuno/overmind/stop.rb

@@ -4,16 +4,22 @@ module Neptuno
   module Overmind
     # Build docker container for Neptuno project
     class Stop < Neptuno::CLI::Base
-      desc 'Overmind: Stop processes inside docker containers'
+      desc "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'
+      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|
+        command_services_to("stop procs", all: options.fetch(:all), services_as_args: services) do |services|
+          services_to_stop = services.intersection(services_with_procs).intersection(running_services)
+          services_to_stop.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")
+            if config.fetch("procfile_manager") == "tmux"
+              system("tmux kill-session -t #{service} 2>/dev/null ")
+              puts "Neptuno killed Tmux session for: #{service}" if `echo $TMUX`.strip.empty?
+            else
+              system("cd #{neptuno_path}/procfiles/#{service} && rm .overmind.sock  > /dev/null 2>&1")
+            end
           end
         end
       end

data/lib/neptuno/services/add.rb

@@ -8,24 +8,18 @@ module Neptuno
       include TTY::Config
       include TTY::File
 
-      desc 'Add a Neptuno service with Git'
+      desc "Add a Neptuno service with Git"
 
       def call(**)
-        name = prompt.ask('? Service name:')
-        add_name_to_config(name)
-        repo = prompt.ask('? Git repo:')
+        name = prompt.ask("? Service name:")
+        repo = prompt.ask("? Git repo:")
         clone_into_folder(repo, name)
-        add_dockerfile(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}")
@@ -62,16 +56,16 @@ module Neptuno
               stdin_open: true
               tty: true
               command: ash
-              build:#{' '}
+              build:#{" "}
                 context: .
                 dockerfile: ./dockerfiles/#{name}/Dockerfile
-              env_file:#{' '}
+              env_file:#{" "}
                 - ./environments/#{name}/default
-              # volumes:#{' '}
+              # volumes:#{" "}
               #   -
-              # ports:#{' '}
+              # ports:#{" "}
               #   -
-              # depends_on:#{' '}
+              # depends_on:#{" "}
               #   -
 
           #---------------------------------------------------------------

data/lib/neptuno/services/destroy.rb

@@ -4,7 +4,7 @@ module Neptuno
   module Services
     # Add project to neptuno
     class Destroy < Neptuno::CLI::Base
-      desc 'Remove a Neptuno service'
+      desc "Remove a Neptuno service"
 
       def call(**)
         puts destroy

data/lib/neptuno/services/list.rb

@@ -4,9 +4,10 @@ module Neptuno
   module Services
     # Add project to neptuno
     class List < Neptuno::CLI::Base
-      desc 'List Neptuno projects'
+      desc "List Neptuno projects"
 
-      def call(**); end
+      def call(**)
+      end
     end
   end
 end

data/lib/neptuno/services/update.rb

@@ -4,15 +4,15 @@ 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'
+      desc "Stashes changes and pulls latest from main/master"
 
-      option :all, type: :boolean, default: false, desc: 'Run on all services'
+      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'
+        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|
+        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`
@@ -22,14 +22,14 @@ module Neptuno
             `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
+              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'
+                puts "Applying stashed changes"
                 system("cd #{neptuno_path}/services/#{service} 2>/dev/null && git stash pop -q #{stash_id}")
               end
             end
-            puts ''
+            puts ""
           end
         end
       end

data/lib/neptuno/templates/{tmuxinator.yml → .tmuxinator.yml}

@@ -1,4 +1,5 @@
-# ./.tmuxinator.yml
+# This file defines what Tmux will do when Neptuno connects to your services. 
+# You can add or remove Tmux windows and panes for each service here.
 
 <% if  YAML.load_file('neptuno.yml')["procfile_manager"] == "tmux" %>
 name: <%= @args[0] %>
@@ -19,9 +20,7 @@ on_project_exit: tmux kill-session -t neptuno
 windows:
   - neptuno:
       panes:
-        - sleep 2 && vim
         - neptuno ps
-        - # host shell
 
   <% @args.each do |service| %>
   - <%= service %>:
@@ -40,5 +39,4 @@ windows:
             neptuno c <%= service %>
     <% end %>
   <% end %>
-
 <% end %>

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

@@ -1,7 +1,18 @@
-version: '3'
-services:
-  alpine:
-    image: alpine
-    tty: true
-    stdin_open: true
-    command: ash
+# This file should contain all your project's services with references to their dockerfiles, env_files, volumes, etc.
+# You can then connect to your services using `neptuno connect <service1 service2 ...>`
+#
+# Example:
+#
+#   version: '3'
+#
+#     services:
+#       alpine:
+#         tty: true
+#         stdin_open: true
+#         build:
+#           context: .
+#           dockerfile: ./dockerfiles/alpine/Dockerfile
+#         env_file:
+#           - ./environments/alpine/local_env
+#         volumes:
+#           - ./services/alpine:/usr/src/app:cached

data/lib/neptuno/templates/neptuno.yml

@@ -0,0 +1,6 @@
+---
+# mode: ide
+# procfile_manager = ["overmind" | "tmux"] # overmind is the default
+configured_services: ''
+services: []
+auto_restart_procs: []

data/lib/neptuno/tty/config.rb

@@ -6,37 +6,71 @@ module Neptuno
     module Config
       include TTY::File
       TTY = ::TTY::Config.new
-      TTY.filename = 'neptuno'
+      TTY.filename = "neptuno"
 
-      ABORT_MESSAGE = 'fatal: there are no registered services. Add one with: neptuno services add'
+      ABORT_MESSAGE = "fatal: there are no registered services. Add one with: neptuno services add"
 
       def config
         TTY
       end
 
-      def docker_compose_services
+      def docker_compose_hash
         source = ::File.read("#{neptuno_path}/docker-compose.yml")
-        docker_compose = begin
+        @@docker_compose ||= begin
           YAML.load(source, aliases: true)
         rescue ArgumentError
           YAML.load(source)
         end
-        docker_compose.fetch('services').keys
+        @@docker_compose
+      end
+
+      def docker_compose_services
+        docker_compose_hash.fetch("services").keys.sort
       end
 
       def auto_restart_procs
-        config.fetch('auto_restart_procs')
+        config.fetch("auto_restart_procs")
       end
 
       def services
-        s = config.fetch('services')
-        s = s.to_a.union(docker_compose_services)
+        s = docker_compose_services
         abort ABORT_MESSAGE if s.count.zero?
-        s.sort
+        s
       end
 
       def configured_services
-        config.fetch('configured_services')
+        config.fetch("configured_services")
+      end
+
+      def running_services
+        `cd #{neptuno_path} && docker-compose ps --status running --services`.split
+      end
+
+      def json_services_status
+        JSON.parse(`cd #{neptuno_path} && docker compose ps --all --format json`).map do |service|
+          [service.dig("Service"), service.dig("Status")]
+        end
+      end
+
+      def starting_services(status: nil)
+        data = status || json_services_status
+        data.select { |service| service.last.match(/starting\)|\(unhealthy\)/) }
+      end
+
+      def healthy_services(status: nil)
+        data = status || json_services_status
+        data.select { |service| service.last.match(/\(healthy\)/) }
+      end
+
+      def services_with_procs
+        `cd #{neptuno_path} && find procfiles -type f -size +0`.split.map { |x| x.split("/")[1] }
+      end
+
+      def get_dependants(services = [])
+        return [] if services.empty?
+
+        deps = services.map { |service| docker_compose_hash.dig("services", service, "depends_on") }.flatten.uniq
+        [deps, get_dependants(deps - services)].flatten.compact.uniq
       end
     end
   end