swarm_cluster_cli_ope 0.4 → 0.5.0.pre.3

data/lib/swarm_cluster_cli_ope/kubernetes/rsync_cfgs/password

@@ -0,0 +1 @@
+root

data/lib/swarm_cluster_cli_ope/kubernetes/rsync_cfgs/rsyncd.conf

@@ -0,0 +1,14 @@
+syslog facility = local3
+read only = no
+list = yes
+auth users = root
+secrets file = /tmp/rsyncd.secrets
+hosts allow = 0.0.0.0/0
+uid = 0
+gid = 0
+
+[archives]
+comment = archives goes here
+path = /
+uid =  root
+gid = root

data/lib/swarm_cluster_cli_ope/kubernetes/rsync_cfgs/rsyncd.secrets

@@ -0,0 +1 @@
+root:root

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/base_decorator.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      module BaseDecorator
+        extend ActiveSupport::Concern
+
+        included do
+
+          delegate :namespace, :context, to: :@stack_cfgs
+
+          private
+
+          # @return [SwarmClusterCliOpe::Kubernetes::Pod]
+          def container
+            return @service if @service.is_a? SwarmClusterCliOpe::Kubernetes::Pod
+            @_container ||= Pod.find_by_selector(service, namespace: namespace, context: context)
+          end
+
+        end
+
+        #  module ClassMethods
+
+        #  end
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/rsync.rb

@@ -0,0 +1,119 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      class Rsync < SwarmClusterCliOpe::SyncConfigs::Base
+
+        include BaseDecorator
+
+        # @return [String]
+        def local_folder
+          @configs[:configs][:local]
+        end
+
+        # @return [String]
+        def remote_folder
+          @configs[:configs][:remote]
+        end
+
+
+        # @return [SwarmClusterCliOpe::ShellCommandResponse]
+        def push
+          execute(direction: :up)
+        end
+
+        # @return [SwarmClusterCliOpe::ShellCommandResponse]
+        def pull
+          execute(direction: :down)
+        end
+
+
+        private
+
+        def execute(direction: :down)
+
+          if container.nil?
+            say "Container non trovato"
+            exit
+          end
+
+
+          if yes? "Attenzione, i dati locali o remoti verranno sovrascritti/cancellati?[y,yes]"
+
+            podname = container.name
+
+            if namespace.nil?
+              say "Mancata configurazione del namespace tramite argomento o .swarm_cluster_project"
+              exit
+            end
+
+            cmd = container.exec(['bash -c "apt update && apt install -yq rsync psmisc"'])
+            if cmd.execute.failed?
+              puts "Problemi nell'installazione di rsync nel pod"
+            else
+              cmd = container.cp_in(File.expand_path("../../rsync_cfgs/rsyncd.conf", __FILE__), "/tmp/.")
+              copy_1 = cmd.execute.failed?
+              cmd = container.cp_in(File.expand_path("../../rsync_cfgs/rsyncd.secrets", __FILE__), "/tmp/.")
+              copy_2 = cmd.execute.failed?
+              cmd = container.exec(['bash -c "chmod 600 /tmp/rsyncd.secrets  && chown root /tmp/*"'])
+              chmod = cmd.execute.failed?
+              if copy_1 or copy_2 or chmod
+                puts "problema nella copia dei file di configurazione nel pod"
+              else
+
+
+                cmd = container.exec('bash -c "rsync --daemon --config=/tmp/rsyncd.conf  --verbose --log-file=/tmp/rsync.log"')
+                if cmd.execute.failed?
+                  say "Rsync non Inizializzato"
+                else
+                  local_port = rand(30000..40000)
+
+                  p = IO.popen(container.base_cmd("port-forward #{podname} #{local_port}:873").string_command)
+                  pid = p.pid
+                  say "PID in execuzione port forward:#{pid}"
+
+                  sleep 1
+
+                  # lanciamo il comando quindi per far rsync
+                  rsync_command = [
+                    "rsync -az --no-o --no-g",
+                    "--delete",
+                    "--password-file=#{ File.expand_path("../../rsync_cfgs/password", __FILE__)}"
+                  ]
+
+                  if direction == :up
+                    rsync_command << "#{local_folder}/."
+                    rsync_command << "rsync://root@0.0.0.0:#{local_port}/archives#{remote_folder}"
+                  else
+                    rsync_command << "rsync://root@0.0.0.0:#{local_port}/archives#{remote_folder}/."
+                    rsync_command << local_folder
+                  end
+                  say "Eseguo rsync #{rsync_command.join(" ")}"
+
+
+                  cmd = ShellCommandExecution.new(rsync_command)
+                  cmd.execute
+
+                  sleep 1
+                  Process.kill("INT", pid)
+
+
+                  say "Eseguo pulizia"
+                  cmd = container.exec('bash -c "killall rsync"')
+                  cmd.execute
+                  cmd = container.exec('bash -c "rm -fr /tmp/rsyncd*"')
+                  cmd.execute
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/sqlite3.rb

@@ -0,0 +1,9 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      class Sqlite3 < SwarmClusterCliOpe::SyncConfigs::Sqlite3
+        include BaseDecorator
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/shell_command_execution.rb

@@ -38,7 +38,7 @@ module SwarmClusterCliOpe
         pid: nil,
         status: nil
       }
-      logger.debug { "SHELL: #{string_command}" }
+      logger.info { "SHELL: #{string_command}" }
       result[:status] = Open4::popen4(string_command) do |pid, stdin, stdout, stderr|
         stdin.close
 

data/lib/swarm_cluster_cli_ope/shell_command_response.rb

@@ -30,7 +30,14 @@ module SwarmClusterCliOpe
     # @param [Object] object_class
     # @return [Array<object_class>]
     def result(object_class: OpenStruct)
-      raw_result[:stdout].split("\n").collect { |s| object_class.new(JSON.parse(s)) }
+      #tento prima di estrapolare direttamente da json e sucessivamente come array
+      begin
+        # questo per k8s, dato che abbiamo come risposta un json vero
+        object_class.new(JSON.parse( raw_result[:stdout]))
+      rescue
+        # questo nel caso siamo in swarm che ci ritorna un array di json
+        raw_result[:stdout].split("\n").collect { |s| object_class.new(JSON.parse(s)) }
+      end
     end
 
     #

data/lib/swarm_cluster_cli_ope/stack_sync_concern.rb

@@ -0,0 +1,128 @@
+require 'active_support/concern'
+
+module SwarmClusterCliOpe
+  module StackSyncConcern
+    extend ActiveSupport::Concern
+
+    included do
+
+      desc "stacksync [DIRECTION:pull|push]", "Si occupa di scaricare|caricare,utilizzando le configurazioni presenti, i dati dallo stack remoto"
+      long_desc <<-LONGDESC.gsub("\n", "\x5")
+      le configurazioni sono contenute nell'array: sync_configs.
+      ogni configurazione è composta da:
+      { 
+       service:"" 
+       how:"" 
+       configs:{ }
+      }
+      - service è il nome del servizio (o nel caso  di k8s una stringa da utilizzare come selettore labels)
+      - how è il come sincronizzare, definendo la tipologia:
+      ---- pg      -> DB TODO
+      ---- mysql   -> DB dump con mysql
+      ---- sqlite3 -> DB: viene eseguita una copia del file
+      ---- rsync   -> RSYNC
+      - configs:  è un hash con le configurazioni per ogni tipo di sincronizzazione
+
+      Possibili CFGS per tipologia:
+      rsync:
+      --local:   -> path cartella locale
+      --remote:  -> path cartella remota (contesto del container)
+
+      sqlite3:
+      --local:   -> path al file
+      --remote:  -> path al file remoto (contesto del container)
+
+      mysql:
+      --local:  -> hash di configurazioni per il DB locale
+        - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+        - mysql_password_env: "MYSQL_PASSWORD"  -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: MYSQL_PASSWORD 
+        - mysql_password: "root"                -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - mysql_user_env: "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER 
+        - mysql_user: "root"                    -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - database_name_env: "MYSQL_DATABASE"   -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE         
+        - database_name: "nome_db"       -> valore in chiaro, in sostituzione della variabile ambiente         
+      --remote: -> hash di configurazioni per il DB remoto
+        - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+        - mysql_password_env: "MYSQL_PASSWORD"  -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: MYSQL_PASSWORD 
+        - mysql_password: "root"                -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - mysql_user_env: "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER 
+        - mysql_user: "root"              -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - database_name_env: "MYSQL_DATABASE"       -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE         
+        - database_name: "MYSQL_DATABASE"       -> valore in chiaro, in sostituzione della variabile ambiente     
+      pg:
+      --local:  -> hash di configurazioni per il DB locale
+        - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+        - pg_password_env: "POSTGRES_USER"      -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: POSTGRES_PASSWORD 
+        - pg_password: ""                       -> valore in chiaro, in sostituzione della variabile ambiente
+        - pg_user_env: "POSTGRES_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: POSTGRES_USER 
+        - pg_user: "postgres"                   -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: postgres
+        - database_name_env: "POSTGRES_DB"      -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: POSTGRES_DB         
+        - database_name: "nome_db"              -> valore in chiaro, in sostituzione della variabile ambiente             
+      --remote: -> hash di configurazioni per il DB remoto
+        - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+        - pg_password_env: "POSTGRES_USER"      -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: POSTGRES_PASSWORD 
+        - pg_password: ""                       -> valore in chiaro, in sostituzione della variabile ambiente
+        - pg_user_env: "POSTGRES_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: POSTGRES_USER 
+        - pg_user: "postgres"                   -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: postgres
+        - database_name_env: "POSTGRES_DB"      -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: POSTGRES_DB         
+        - database_name: "nome_db"              -> valore in chiaro, in sostituzione della variabile ambiente     
+              
+
+      EXAMPLE:
+      Esempio di sincronizzazione di un file sqlite3 e una cartella
+      {
+        "stack_name": "test1",
+        "sync_configs": [
+          {
+            "service": "second",
+            "how": "rsync",
+            "configs": {
+              "remote": "/test_bind",
+              "local": "./uploads"
+            }
+          },
+          {
+            "service": "test_sqlite3",
+            "how": "sqlite3",
+            "configs": {
+              "remote": "/cartella_sqlite3/esempio.sqlite3",
+              "local": "./development.sqlite3"
+            }
+          }
+        ]
+      }
+      LONGDESC
+
+      def stacksync(direction)
+        direction = case direction
+                    when 'push'
+                      :push
+                    when 'pull'
+                      :pull
+                    else
+                      raise "ONLY [push|pull] action accepted"
+                    end
+        cfgs.env(options[:environment]) do |cfgs|
+          sync_cfgs = cfgs.sync_configurations
+          if sync_cfgs.empty?
+            say "Attenzione, configurazioni di sincronizzazione vuoto. Leggere la documentazione"
+          else
+            sync_cfgs.each do |sync|
+              say "----------->>>>>>"
+              say "[ #{sync.class.name} ]"
+              sync.send(direction)
+              say "COMPLETE"
+              say "<<<<<<-----------"
+            end
+          end
+        end
+      end
+
+
+    end
+
+    #  module ClassMethods
+
+    #  end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/base.rb

@@ -9,7 +9,7 @@ module SwarmClusterCliOpe
       attr_accessor :configs
 
       # @param [Hash] configs
-      # @param [Continuation] stack_cfgs
+      # @param [Configuration] stack_cfgs
       def initialize(stack_cfgs, configs)
         super()
         @configs = configs

data/lib/swarm_cluster_cli_ope/sync_configs/base_database.rb

@@ -4,12 +4,12 @@ module SwarmClusterCliOpe
 
       # @return [SwarmClusterCliOpe::SyncConfigs::EnvConfigs]
       def remote
-        self.class::EnvConfigs.new(self, @configs[:configs][:remote] || {}, -> { container })
+        self.class::EnvConfigs.new(self, @configs.dig(:configs, :remote) || {}, -> { container })
       end
 
       # @return [SwarmClusterCliOpe::SyncConfigs::EnvConfigs]
       def local
-        self.class::EnvConfigs.new(self, @configs[:configs][:local] || {}, -> { local_container })
+        self.class::EnvConfigs.new(self, @configs.dig(:configs, :local) || {}, -> { local_container })
       end
 
       ##
@@ -28,11 +28,13 @@ module SwarmClusterCliOpe
               database_name: #{local.database_name}
               username: #{local.username}
               password: #{local.password}
+              version: #{local.database_version}
             remote:
               service_name: #{remote.service_name}
               database_name: #{remote.database_name}
               username: #{remote.username}
-              password: #{remote.password}"
+              password: #{remote.password}
+              version: #{remote.database_version}"
 
       end
 

data/lib/swarm_cluster_cli_ope/sync_configs/mysql.rb

@@ -34,6 +34,8 @@ module SwarmClusterCliOpe
         define_cfgs :username, default_env: "MYSQL_USER", configuration_name: :mysql_user, default_value: 'root'
         define_cfgs :password, default_env: "MYSQL_PASSWORD", configuration_name: :mysql_password, default_value: 'root'
 
+        define_cfgs :database_version, default_env: "MYSQL_MAJOR", configuration_name: :mysql_version
+
       end
 
 

data/lib/swarm_cluster_cli_ope/sync_configs/post_gres.rb

@@ -2,28 +2,27 @@ module SwarmClusterCliOpe
   module SyncConfigs
     class PostGres < BaseDatabase
 
-      # @return [TrueClass, FalseClass]
+
       def pull
         resume('pull')
 
-        dump_cmd = dump_cmd(remote.username, remote.password, remote.database_name)
-        logger.info{ "DUMP  COMMAND: #{dump_cmd.join(' ')}"}
         if yes?("Confermare il comando?[y,yes]")
+
           tmp_file = "/tmp/#{Time.now.to_i}.sql.gz"
-          container.exec("bash -c '#{dump_cmd.join(' ')}' > #{tmp_file}")
-          local_container.copy_in(tmp_file, tmp_file)
+          dump_cmd(remote, tmp_file)
+          local.container.copy_in(tmp_file, tmp_file)
 
           # drop old db and recreate
-          drop_cmd = drop_cmd(local.username, local.password, local.database_name)
-          logger.info{ "DROP  COMMAND: #{drop_cmd.join(' ')}"}
-          local_container.exec("bash -c '#{drop_cmd.join(' ')}'")
-          create_cmd = create_cmd(local.username, local.password, local.database_name)
-          logger.info{ "CREATE COMMAND: #{create_cmd.join(' ')}"}
-          local_container.exec("bash -c '#{create_cmd.join(' ')}'")
-
-          restore_cmd = restore_cmd(local.username, local.password, local.database_name, tmp_file)
-          logger.info{ "RESTORE COMMAND: #{restore_cmd.join(' ')}"}
-          local_container.exec("bash -c '#{restore_cmd.join(' ')}'")
+          if Gem::Version.new(local.database_version) <= Gem::Version.new("12")
+            close_connections_and_drop_cmd(local)
+          else
+            raise "DA ANALIZZARE QUANDO LA 13 disponibile....dropdb ha un force come parametro"
+          end
+
+          create_cmd(local)
+
+          restore_cmd(local, tmp_file)
+
         end
         true
       end
@@ -32,25 +31,22 @@ module SwarmClusterCliOpe
       def push
         resume('PUSH')
 
-        dump_cmd = dump_cmd(local.username, local.password, local.database_name)
-        say "DUMP COMMAND: #{dump_cmd.join(' ')}"
         if yes?("ATTENZIONE !!!!!!PUSH!!!!! - Confermare il comando?[y,yes]")
+
           tmp_file = "/tmp/#{Time.now.to_i}.sql.gz"
-          local_container.exec("bash -c '#{dump_cmd.join(' ')}' > #{tmp_file}")
-          container.copy_in(tmp_file, tmp_file)
+          dump_cmd(local, tmp_file)
+          remote.container.copy_in(tmp_file, tmp_file)
 
           # drop old db and recreate
-          drop_cmd = drop_cmd(remote.username, remote.password, remote.database_name)
-          logger.info{ "DROP  COMMAND: #{drop_cmd.join(' ')}"}
-          container.exec("bash -c '#{drop_cmd.join(' ')}'")
+          if Gem::Version.new(local.database_version) <= Gem::Version.new("12")
+            close_connections_and_drop_cmd(remote)
+          else
+            raise "DA ANALIZZARE QUANDO LA 13 disponibile....dropdb ha un force come parametro"
+          end
+          create_cmd(remote)
 
-          create_cmd = create_cmd(remote.username, remote.password, remote.database_name)
-          logger.info{ "CREATE COMMAND: #{create_cmd.join(' ')}"}
-          container.exec("bash -c '#{create_cmd.join(' ')}'")
+          restore_cmd(remote, tmp_file)
 
-          restore_cmd = restore_cmd(remote.username, remote.password, remote.database_name, tmp_file)
-          say "RESTORE COMMAND: #{restore_cmd.join(' ')}"
-          container.exec("bash -c '#{restore_cmd.join(' ')}'")
         end
         true
       end
@@ -63,53 +59,101 @@ module SwarmClusterCliOpe
         define_cfgs :username, default_env: "POSTGRES_USER", configuration_name: :pg_user, default_value: 'postgres'
         define_cfgs :password, default_env: "POSTGRES_PASSWORD", configuration_name: :pg_password
 
+        define_cfgs :database_version, default_env: "PG_MAJOR", configuration_name: :pg_version
+
       end
 
       private
 
-      def create_cmd(username, password, database_name)
+      # @param [EnvConfigs] config
+      def create_cmd(config)
         create_cmd = []
-        create_cmd << "PGPASSWORD=\"#{password}\""
+        create_cmd << "PGPASSWORD=\"#{config.password}\""
         create_cmd << 'createdb'
-        create_cmd << "--username=#{username}"
-        create_cmd << database_name
-      end
+        create_cmd << "--username=#{config.username}"
+        create_cmd << config.database_name
 
-      def drop_cmd(username, password, database_name)
-        drop_cmd = []
-        drop_cmd << "PGPASSWORD=\"#{password}\""
-        drop_cmd << 'dropdb'
-        drop_cmd << "--username=#{username}"
-        drop_cmd << database_name
-        drop_cmd
+        logger.info { "CREATE COMMAND: #{create_cmd.join(' ')}" }
+        config.container.exec("bash -c '#{create_cmd.join(' ')} || true'")
       end
 
-      def restore_cmd(username, password, database_name, tmp_file)
+      # @param [EnvConfigs] config
+      # def drop_cmd(config)
+      #   drop_cmd = []
+      #   drop_cmd << "PGPASSWORD=\"#{config.password}\""
+      #   drop_cmd << 'dropdb'
+      #   drop_cmd << '--if-exists'
+      #   drop_cmd << "--username=#{config.username}"
+      #   drop_cmd << config.database_name
+      #   drop_cmd
+      #
+      #   logger.info { "DROP  COMMAND: #{drop_cmd.join(' ')}" }
+      #   config.container.exec("bash -c '#{drop_cmd.join(' ')}'")
+      # end
+
+      # @param [EnvConfigs] config
+      def restore_cmd(config, tmp_file)
         restore_cmd = []
-        restore_cmd << "PGPASSWORD=\"#{password}\""
+        restore_cmd << "PGPASSWORD=\"#{config.password}\""
         restore_cmd << 'pg_restore'
         restore_cmd << '--no-acl'
         restore_cmd << '--no-owner'
-        restore_cmd << "--username=#{username}"
-        restore_cmd << "--dbname=#{database_name}"
+        restore_cmd << "--username=#{config.username}"
+        restore_cmd << "--dbname=#{config.database_name}"
         restore_cmd << tmp_file
         restore_cmd
+
+        logger.info { "RESTORE COMMAND: #{restore_cmd.join(' ')}" }
+        config.container.exec("bash -c '#{restore_cmd.join(' ')}'")
       end
 
-      def dump_cmd(username, password, database_name)
+      # @param [EnvConfigs] config
+      def dump_cmd(config, file)
         dump_cmd = []
-        dump_cmd << "PGPASSWORD=\"#{password}\""
+        dump_cmd << "PGPASSWORD=\"#{config.password}\""
         dump_cmd << 'pg_dump'
         dump_cmd << '--no-acl'
         dump_cmd << '--no-owner'
-        dump_cmd << "--username=#{username}"
+        dump_cmd << "--username=#{config.username}"
         dump_cmd << '--format=custom'
         dump_cmd << '--compress=9'
-        dump_cmd << database_name
+        dump_cmd << config.database_name
         dump_cmd
+
+        logger.info { "DUMP  COMMAND: #{dump_cmd.join(' ')}" }
+        config.container.exec("bash -c '#{dump_cmd.join(' ')}' > #{file}")
+
       end
 
 
+      # @param [EnvConfigs] config
+      def close_connections_and_drop_cmd(config)
+        cmd = []
+        cmd << "PGPASSWORD=\"#{config.password}\""
+
+        sql = []
+        sql << "SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname =  '\"'\"'#{config.database_name}'\"'\"' AND pid <> pg_backend_pid();;"
+        sql << "DROP DATABASE IF EXISTS #{config.database_name};"
+
+        cmd << "echo \"#{sql.join(" ")}\" "
+        cmd << '|'
+        cmd << 'psql'
+        cmd << "-U #{config.username}"
+        cmd << "postgres"
+        cmd
+
+        logger.info { "CLOSE CONNECTIONS COMMAND: #{cmd.join(' ')}" }
+        config.container.exec("bash -c '#{cmd.join(' ')}'")
+      end
+
+      # quello che fa capistrano quando copia in locale - utenze inventate
+      # gzip -d cortobio_production_new_2020-09-10-171742.sql.gz  &&
+      #   PGPASSWORD='root' psql -c "SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname = 'development' AND pid <> pg_backend_pid();;"  -U root  -h 0.0.0.0  -p 32790  development;
+      # PGPASSWORD='root' dropdb  -U root  -h 0.0.0.0  -p 32790  development;
+      # PGPASSWORD='root' createdb  -U root  -h 0.0.0.0  -p 32790  development;
+      # PGPASSWORD='root' psql  -U root  -h 0.0.0.0  -p 32790  -d development < ./cortobio_production_new_2020-09-10-171742.sql
+
+
     end
   end
 end