vmc_knife 0.0.7 → 0.0.8

data/lib/vmc_knife/cli_extensions.rb

@@ -72,8 +72,8 @@ class VMC::Cli::KnifeRunner < VMC::Cli::Runner
       else
         set_cmd(:knife, :configure_etc_avahi_aliases, @args.size) # too many
       end
-    when 'configure-applications'
-      usage('vmc_knife configure-applications [<applications_regexp>]')
+    when 'configure-applications','configure-apps'
+      usage('vmc_knife configure-apps [<applications_regexp>]')
       @args.shift # consumes the argument.
       if @args.size <= 2
         set_cmd(:knifeapps, :configure_applications, @args.size)
@@ -96,32 +96,32 @@ class VMC::Cli::KnifeRunner < VMC::Cli::Runner
       else
         set_cmd(:knifeapps, :configure_recipes, @args.size) # too many
       end
-    when 'upload-applications'
-      usage('vmc_knife upload-applications [<applications_regexp>]')
+    when 'upload-applications','upload-apps'
+      usage('vmc_knife upload-apps [<applications_regexp>]')
       @args.shift # consumes the argument.
       if @args.size <= 2
         set_cmd(:knifeapps, :upload_applications, @args.size)
       else
         set_cmd(:knifeapps, :upload_applications, @args.size) # too many
       end
-    when 'start-applications'
-      usage('vmc_knife start-applications [<applications_regexp>]')
+    when 'start-applications','start-apps'
+      usage('vmc_knife start-apps [<applications_regexp>]')
       @args.shift # consumes the argument.
       if @args.size <= 2
         set_cmd(:knifeapps, :start_applications, @args.size)
       else
         set_cmd(:knifeapps, :start_applications, @args.size) # too many
       end
-    when 'stop-applications'
-      usage('vmc_knife stop-applications [<applications_regexp>]')
+    when 'stop-applications','stop-apps'
+      usage('vmc_knife stop-apps [<applications_regexp>]')
       @args.shift # consumes the argument.
       if @args.size <= 2
         set_cmd(:knifeapps, :stop_applications, @args.size)
       else
         set_cmd(:knifeapps, :stop_applications, @args.size) # too many
       end
-    when 'restart-applications'
-      usage('vmc_knife restart-applications [<applications_regexp>]')
+    when 'restart-applications','restart-apps'
+      usage('vmc_knife restart-apps [<applications_regexp>]')
       @args.shift # consumes the argument.
       if @args.size <= 2
         set_cmd(:knifeapps, :restart_applications, @args.size)
@@ -136,8 +136,56 @@ class VMC::Cli::KnifeRunner < VMC::Cli::Runner
       else
         set_cmd(:knifeapps, :delete_all, @args.size) # too many
       end
+    when 'data-shell','psql','mongo'
+      usage('vmc_knife data-shell [<data-service-name>] [<app-name>]')
+      @args.shift # consumes the argument.
+      if @args.size <= 2
+        set_cmd(:knifeapps, :data_shell, @args.size)
+      else
+        set_cmd(:knifeapps, :data_shell, @args.size) # too many
+      end
+    when 'data-apply-privileges'
+      usage('vmc_knife data-apply-privileges [<data-service-name>] [<app-name>]')
+      @args.shift # consumes the argument.
+      if @args.size <= 2
+        set_cmd(:knifeapps, :data_apply_privileges, @args.size)
+      else
+        set_cmd(:knifeapps, :data_apply_privileges, @args.size) # too many
+      end
+    when 'data-credentials'
+      usage('vmc_knife data-credentials [<data-service-name>] [<app-name>]')
+      @args.shift # consumes the argument.
+      if @args.size <= 2
+        set_cmd(:knifeapps, :data_credentials, @args.size)
+      else
+        set_cmd(:knifeapps, :data_credentials, @args.size) # too many
+      end
+    when 'data-drop'
+      usage('vmc_knife data-drop [<data-service-name>] [<tables-collection-regexp>]')
+      @args.shift # consumes the argument.
+      if @args.size <= 3
+        set_cmd(:knifeapps, :data_drop, @args.size)
+      else
+        set_cmd(:knifeapps, :data_drop, @args.size) # too many
+      end
+    when 'data-import'
+      usage('vmc_knife data-import [<data-service-name>] [<tables-collection-regexp>]')
+      @args.shift # consumes the argument.
+      if @args.size <= 3
+        set_cmd(:knifeapps, :data_import, @args.size)
+      else
+        set_cmd(:knifeapps, :data_import, @args.size) # too many
+      end
+    when 'data-export'
+      usage('vmc_knife data-export [<data-service-name>] [<tables-collection-regexp>]')
+      @args.shift # consumes the argument.
+      if @args.size <= 3
+        set_cmd(:knifeapps, :data_export, @args.size)
+      else
+        set_cmd(:knifeapps, :data_export, @args.size) # too many
+      end
     when 'help'
-      display "vmc_knife expand-manifest|login|start/stop/restart-applications|upload-applications|configure-all|configure-recipes|configure-applications|configure-services|delete-all|configure-vcap|configure-vcap-mdns|configure-vcap-etc-hosts [<manifest_path>]"
+      display "vmc_knife expand-manifest|login|start/stop/restart-apps|upload-apps|configure-all|configure-recipes|configure-apps|configure-services|delete-all|configure-vcap|configure-vcap-mdns|configure-vcap-etc-hosts|data-shell [<manifest_path>]"
     else
       super
     end

data/lib/vmc_knife/commands/knife_cmds.rb

@@ -65,7 +65,7 @@ module VMC::Cli::Command
         man = load_manifest(nil)
         uri = man['target']
       end
-      update_aliases = VMC::KNIFE::VCAPUpdateAvahiAliases.new(nil,man,client)
+      update_aliases = VMC::KNIFE::VCAPUpdateAvahiAliases.new(nil,man,client,/.*/)
       update_hosts = VMC::KNIFE::VCAPUpdateEtcHosts.new(uri,manifest_file_path,client)
       update_hosts.set_all_uris(update_aliases.all_uris)
       if update_hosts.update_pending()
@@ -76,7 +76,7 @@ module VMC::Cli::Command
     # updates /etc/avahi/aliases
     def configure_etc_avahi_aliases(etc_avahi_aliases=nil,manifest_file_path=nil)
       man = load_manifest(manifest_file_path)
-      update_aliases = VMC::KNIFE::VCAPUpdateAvahiAliases.new(etc_avahi_aliases,man,client,/.*/)
+      update_aliases = VMC::KNIFE::VCAPUpdateAvahiAliases.new(etc_avahi_aliases,man,client)
       update_aliases.do_exec = true
       update_aliases.execute
     end
@@ -187,6 +187,9 @@ module VMC::Cli::Command
     # @param app_role_names The names of the apps in each recipe; nil: configure all apps found.
     def configure(recipes_regexp=nil,app_names_regexp=nil,service_names_regexp=nil,manifest_file_path=nil)
       man = load_manifest(manifest_file_path)
+      recipes_regexp = as_regexp(recipes_regexp)
+      app_names_regexp = as_regexp(app_names_regexp)
+      service_names_regexp = as_regexp(service_names_regexp)
       configurer = VMC::KNIFE::RecipesConfigurationApplier.new(man,client,recipes_regexp,app_names_regexp,service_names_regexp)
       if VMC::Cli::Config.trace
         display "Pending updates"
@@ -196,28 +199,58 @@ module VMC::Cli::Command
     end
     
     def upload_applications(app_names_regexp=nil,manifest_file_path=nil)
-      recipe_configuror(:upload,nil,nil,app_names_regexp,manifest_file_path)
+      recipe_configuror(:upload,nil,app_names_regexp,nil,manifest_file_path)
     end
     def start_applications(app_names_regexp=nil,manifest_file_path=nil)
-      recipe_configuror(:start,nil,nil,app_names_regexp,manifest_file_path)
+      recipe_configuror(:start,nil,app_names_regexp,nil,manifest_file_path)
     end
     def stop_applications(app_names_regexp=nil,manifest_file_path=nil)
-      recipe_configuror(:stop,nil,nil,app_names_regexp,manifest_file_path)
+      recipe_configuror(:stop,nil,app_names_regexp,nil,manifest_file_path)
     end
     def restart_applications(app_names_regexp=nil,manifest_file_path=nil)
-      recipe_configuror(:restart,nil,nil,app_names_regexp,manifest_file_path)
+      recipe_configuror(:restart,nil,app_names_regexp,nil,manifest_file_path)
     end
     def delete_all(app_names_regexp=nil,manifest_file_path=nil)
-      recipe_configuror(:delete,nil,nil,app_names_regexp,manifest_file_path)
+      recipe_configuror(:delete,nil,app_names_regexp,nil,manifest_file_path)
+    end
+    def data_shell(data_names_regexp=nil,manifest_file_path=nil)
+      recipe_configuror(:shell,nil,nil,data_names_regexp,manifest_file_path)
+    end
+    def data_credentials(data_names_regexp=nil,manifest_file_path=nil)
+      recipe_configuror(:credentials,nil,nil,data_names_regexp,manifest_file_path)
+    end
+    def data_apply_privileges(data_names_regexp=nil,manifest_file_path=nil)
+      recipe_configuror(:apply_privileges,nil,nil,data_names_regexp,manifest_file_path)
+    end
+    def data_import(data_names_regexp=nil,app_name=nil,file_names=nil,manifest_file_path=nil)
+      recipe_configuror(:import,nil,nil,data_names_regexp,manifest_file_path,
+                        {:file_names=>file_names, :app_name=>app_name})
+    end
+    def data_export(data_names_regexp=nil,app_name=nil,file_names=nil,manifest_file_path=nil)
+      recipe_configuror(:export,nil,nil,data_names_regexp,manifest_file_path,
+                        {:file_names=>file_names, :app_name=>app_name})
+    end
+    def data_drop(data_names_regexp=nil,collection_or_table_names=nil,manifest_file_path=nil)
+      recipe_configuror(:drop,nil,nil,data_names_regexp,manifest_file_path,
+                        {:collection_or_table_names=>collection_or_table_names})
     end
     
-    def recipe_configuror(method_sym_name,recipes_regexp=nil,app_names_regexp=nil,service_names_regexp=nil,manifest_file_path=nil)
+    def recipe_configuror(method_sym_name,recipes_regexp=nil,app_names_regexp=nil,service_names_regexp=nil,manifest_file_path=nil,opts=nil)
       man = load_manifest(manifest_file_path)
-      configurer = VMC::KNIFE::RecipesConfigurationApplier.new(man,client,recipes_regexp,app_names_regexp,service_names_regexp)
+      recipes_regexp = as_regexp(recipes_regexp)
+      app_names_regexp = as_regexp(app_names_regexp)
+      service_names_regexp = as_regexp(service_names_regexp)
+      configurer = VMC::KNIFE::RecipesConfigurationApplier.new(man,client,recipes_regexp,app_names_regexp,service_names_regexp,opts)
       method_object = configurer.method(method_sym_name)
       method_object.call
     end
     
+    def as_regexp(arg)
+      if arg != nil && arg.kind_of?(String) && !arg.strip.empty?
+        Regexp.new(arg)
+      end
+    end
+    
   end
   
 end

data/lib/vmc_knife/data_services.rb

@@ -0,0 +1,364 @@
+require 'yaml'
+require "interact"
+require 'tempfile'
+require 'tmpdir'
+
+module VMC
+  module KNIFE
+    
+    # returns only the result raw from psql
+    PSQL_RAW_RES_ARGS="-P format=unaligned -P footer=off -P tuples_only=on"
+
+    # Reads the cloud_controller config file for the connection parameters to ccdb.
+    def self.get_ccdb_credentials(ccdb_yml_path="#{ENV['HOME']}/cloudfoundry/config/cloud_controller.yml", db_type='production')
+      cc_conf = File.open( ccdb_yml_path ) do |yf| YAML::load( yf ) end
+      db = cc_conf['database_environment'][db_type]
+      db
+    end
+    
+    def self.get_postgresql_node_credentials(postgresql_node_yml_path="#{ENV['HOME']}/cloudfoundry/config/postgresql_node.yml")
+      db = File.open( postgresql_node_yml_path ) do |yf| YAML::load( yf ) end
+      db['postgresql']
+    end
+        
+    def self.get_app_id(app_name)
+       db=get_ccdb_credentials()
+       app_id = `psql --username #{db['username']} --dbname #{db['database']} -c \"select id from apps where name='#{app_name}'\" #{PSQL_RAW_RES_ARGS}`
+       app_id
+    end
+    def self.get_service_config_id(service_name)
+       db=get_ccdb_credentials()
+       #todo add the user_id
+       service_config_id = `psql --username #{db['username']} --dbname #{db['database']} -c \"select id from service_configs where alias='#{service_name}'\" #{PSQL_RAW_RES_ARGS}`
+       service_config_id
+    end
+    
+    # Returns a hash of the credentials for a data-service
+    # For example for postgres:
+    #--- 
+    #name: dc82ca85dfef740b7841211f354068beb
+    #host: 192.168.1.6
+    #hostname: 192.168.1.6
+    #port: 5432
+    #user: uafe612fbe7714af0ab04db22e199680d
+    #username: uafe612fbe7714af0ab04db22e199680d
+    #password: pd829916bfac34b3185e0f1158bf8920b
+    #node_id: postgresql_node_0  
+    #
+    # For example for mongo:
+    #hostname: 192.168.0.103                       +
+    #host: 192.168.0.103                           +
+    #port: 25003                                   +
+    #name: 266401da-6853-4657-b212-814bd6f9d844    +
+    #db: db                                        +
+    #username: c417f26c-6f49-4dd5-a208-216107279c7a+
+    #password: 8ab08355-6509-48d5-974f-27c853b842f5+
+    #node_id: mongodb_node_0
+    #
+    def self.get_credentials(service_name, app_name=nil)
+       db=get_ccdb_credentials()
+       if app_name.nil?
+         credentials_str = `psql --username #{db['username']} --dbname #{db['database']} -c \"select credentials from service_configs where alias='#{service_name}'\" #{PSQL_RAW_RES_ARGS}`
+       else
+         app_id = get_app_id(app_name)
+         service_config_id = get_service_config_id(service_name)
+         credentials_str = `psql --username #{db['username']} --dbname #{db['database']} -c \"select credentials from service_bindings where app_id = '#{app_id}' and service_config_id='#{service_config_id}'\" #{PSQL_RAW_RES_ARGS}`
+       end
+       res = Hash.new
+       credentials_str.split("\n").each do | line |
+         line =~ /([\w]*): ([\w|\.|-]*)$/
+         res[$1] = $2 if $2
+       end
+       res
+    end
+    
+    def self.pg_connect_cmd(credentials_hash, executable='psql',as_admin=false, other_params="")
+      if executable =~ /vacuumlo$/
+        # we don't have TEMP privilegeswhich are required by vacuumlo...
+        #"export PGPASSWORD=#{credentials_hash['password']}; #{executable} -h #{credentials_hash['hostname']} -p #{credentials_hash['port']} -U #{credentials_hash['username']} #{credentials_hash['name']}"
+        #workaround: use the superuser in the meantime:
+        db=get_postgresql_node_credentials()
+        db_arg = credentials_hash['name']
+        return "export PGPASSWORD=#{db['pass']}; #{executable} -h #{db['host']} -p #{db['port']} -U #{db['user']} #{other_params} #{db_arg}"
+      elsif executable =~ /pg_dump$/
+        db_arg = "#{other_params} #{credentials_hash['name']}"
+      else
+        #the other params are at the end
+        db_arg = "--dbname=#{credentials_hash['name']} #{other_params}"
+      end
+      if as_admin
+        # usually as vcap/vcap
+        db=get_postgresql_node_credentials()
+        "export PGPASSWORD=#{db['pass']}; #{executable} --host=#{db['host']} --port=#{db['port']} --username=#{db['user']} #{db_arg}"
+      else
+        "export PGPASSWORD=#{credentials_hash['password']}; #{executable} --host=#{credentials_hash['hostname']} --port=#{credentials_hash['port']} --username=#{credentials_hash['username']} #{db_arg}"
+      end
+    end
+    
+    # command_files or command.
+    def self.data_service_console(credentials_hash, commands_file="",as_admin=false)
+      if credentials_hash['db'] #so far it has always been equal to 'db'
+        # It is a mongo service
+        #/home/ubuntu/cloudfoundry/.deployments/intalio_devbox/deploy/mongodb/bin/mongo 127.0.0.1:25003/db 
+        #-u c417f26c-6f49-4dd5-a208-216107279c7a -p 8ab08355-6509-48d5-974f-27c853b842f5
+        # Todo: compute the mongoshell path (?)
+        mongo_shell=find_mongo_exec()
+        cmd = "#{mongo_shell} -u #{credentials_hash['username']} -p #{credentials_hash['password']} #{credentials_hash['hostname']}:#{credentials_hash['port']}/#{credentials_hash['db']}"
+        puts "Executing #{cmd}"
+        if commands_file
+          if File.exists? commands_file
+            # not supported yet.
+            commands_file = "--eval \"#{`cat commands_file`}"
+          else
+            commands_file = "--eval \"#{commands_file}\""
+          end
+          `#{cmd} #{commands_file}`
+        else
+          # Replaces the current process.
+          exec cmd
+        end
+      else
+        cmd = pg_connect_cmd(credentials_hash, 'psql')
+        if commands_file
+          if File.exists? commands_file
+            commands_file = "-f #{commands_file} #{PSQL_RAW_RES_ARGS}"
+          else
+            commands_file = "-c \"#{commands_file}\" #{PSQL_RAW_RES_ARGS}"
+          end
+          `#{cmd} #{commands_file}`
+        else
+          # Replaces the current process.
+          exec cmd
+        end
+      end
+    end
+    
+    def self.find_mongo_exec()
+      mongo=`which mongo`
+      return mongo unless mongo.nil? || mongo.empty?
+      mongo_files = Dir.glob("#{ENV['HOME']}/cloudfoundry/.deployments/*/deploy/mongodb/bin/mongo")
+      mongo_files.first unless mongo_files.empty?
+    end
+    
+    def self.as_regexp(arg)
+      if arg != nil && arg.kind_of?(String) && !arg.strip.empty?
+        Regexp.new(arg)
+      end
+    end
+    
+    class RecipesConfigurationApplier
+      def shell()
+        @data_services.each do |data_service|
+          app_name = opts()[:app_name] if opts()
+          data_service.shell(app_name)
+        end
+      end
+      def credentials()
+        @data_services.each do |data_service|
+          data_service.credentials
+        end
+      end
+      def apply_privileges()
+        @data_services.each do |data_service|
+          data_service.apply_privileges
+        end
+      end
+      def import()
+        file_names = @opts[:file_names] if @opts
+        app_name = @opts[:app_name] if @opts
+        @data_services.each do |data_service|
+          data_service.import(app_name,file_names)
+        end
+      end
+      def export()
+        file_names = opts()[:file_names] if opts()
+        app_name = opts()[:app_name] if opts()
+        @data_services.each do |data_service|
+          data_service.export(app_name,file_names)
+        end
+      end
+      def drop()
+        collection_or_table_names = @opts[:collection_or_table_names] if @opts
+        @data_services.each do |data_service|
+          data_service.drop(collection_or_table_names)
+        end
+      end
+      
+    end
+    
+    class DataService
+      include Interactive
+      
+      # The credentials hash for this data-service
+      def credentials(app_name=nil)
+        #bound_app is the name of an app bound to the dat-service and that credentials
+        #should be used to access the data-service.
+        #for example if an app creates large objects you will need to use
+        #the credentials of that app to find the objects.
+        app_name ||= @wrapped['director']['bound_app'] if @wrapped['director']
+        @credentials ||= VMC::KNIFE.get_credentials(name(), app_name)
+        @credentials
+      end
+      
+      # Connect to the mongo js shell or the psql shell.
+      def shell(commands_file=nil,as_admin=false)
+        VMC::KNIFE.data_service_console(credentials(),commands_file,as_admin)
+      end
+      
+      def import(app_name=nil,file=nil)
+        file ||= @wrapped['director']['import_url'] if @wrapped['director']
+        if file.nil?
+          files = Dir.glob("#{name()}.*")
+          raise "Unable to locate the database file to import." if files.empty?
+          file = files.first
+        end
+        is_tmp = false
+        current_wd = Dir.pwd
+        begin
+          if file =~ /^https?:\/\// || file =~ /^ftp:\/\//
+            url = file
+            is_tmp = true
+            if file =~ /[^\/]*$/
+              basename = $0
+            end
+            tempfile = Tempfile.new("import_db_#{basename}")
+            wget_args = @application_json['repository']['wget_args']
+            if wget_args.nil?
+              wget_args_str = ""
+            elsif wget_args.kind_of? Array
+              wget_args_str = wget_args.join(' ')
+            elsif wget_args.kind_of? String
+              wget_args_str = wget_args
+            end
+            `wget #{wget_args_str} --output-document=#{tempfile.path} #{url}`
+            file = tempfile.path
+          end
+          #unzip if necessary (in progress)
+          
+          if /\.tgz$/ =~ file || /\.tar\.gz$/ =~ file
+            tmp_dir = Dir.mktmpdir
+            Dir.chdir(tmp_dir.path)
+            `tar zxvf #{file.path}`
+          elsif /\.tar$/ =~ file
+            tmp_dir = Dir.mktmpdir
+            Dir.chdir(tmp_dir.path)
+            `tar xvf #{file}`
+          elsif /\.zip$/ =~ file
+            tmp_dir = Dir.mktmpdir
+            Dir.chdir(tmp_dir.path)
+            `unzip #{file}`
+          end
+          if tmp_dir
+            `rm #{file}`
+            files = Dir.glob("*.sql") if is_postgresql
+            files = Dir.glob("*.bson") if is_mongodb
+            files ||= Dir.glob("*")
+            raise "Can't find the db-dump file." if files.empty?
+            file = files.first
+          end
+          
+          if is_postgresql
+            `chmod o+w #{file}`
+            #TODO:
+            if /\.sql$/ =~ file
+              other_params="--file #{file} --quiet"
+              cmd = VMC::KNIFE.pg_connect_cmd(credentials(app_name), 'psql',as_admin=false, other_params)
+              #`psql --dbname #{dbname} --file #{file} --clean --quiet --username #{rolename}`
+            else
+              other_params="--clean --no-acl --no-privileges --no-owner #{file}"
+              cmd = VMC::KNIFE.pg_connect_cmd(credentials(app_name), 'pg_restore',false, other_params)
+              #`pg_restore --dbname=#{dbname} --username=#{username} --no-acl --no-privileges --no-owner #{file}`
+            end
+            puts cmd
+            puts `#{cmd}`
+            `chmod o-w #{file}`
+          else
+            raise "Unsupported type of data-service. Postgresql is the only supported service at the moment."
+          end
+        ensure
+          file.unlink if is_tmp  # deletes the temp file
+          tmp_dir.unlink if tmp_dir  # deletes the temp directory
+          Dir.chdir(current_wd)
+        end
+      end
+      
+      def export(app_name=nil,file=nil)
+        if is_postgresql
+          if file.nil?
+            extension = @wrapped['director']['file_extension'] if @wrapped['director']
+            extension = is_mongodb() ? "bson" : "sql"
+            file = "#{name()}.#{extension}"
+          end
+          `touch #{file}`
+          `chmod o+w #{file}`
+          puts "Exports the database #{credentials(app_name)['name']} in #{file}"
+          
+          #sudo -u postgres env PGPASSWORD=$PGPASSWORD dbname=$DBNAME DUMPFILE=$DUMPFILE pg_dump --format=p --file=$DUMPFILE --no-owner --clean --blobs --no-acl --oid --no-tablespaces $DBNAME
+
+          cmd = VMC::KNIFE.pg_connect_cmd(credentials(app_name), 'pg_dump', false, "--format=p --file=#{file} --no-owner --clean --oids --blobs --no-acl --no-privileges --no-tablespaces")
+          puts cmd
+          puts `#{cmd}`
+          `chmod o-w #{file}`
+        end
+      end
+      
+      def is_postgresql()
+        credentials()['db'] == nil
+      end
+                                                                                                                                                      
+      def is_mongodb()
+        credentials()['db'] != nil
+      end
+                                                                                                                                                      
+      def apply_privileges()
+        if is_postgresql()
+          cmd_acl="GRANT CREATE ON SCHEMA PUBLIC TO PUBLIC;\
+          GRANT ALL ON ALL TABLES IN SCHEMA PUBLIC TO PUBLIC;\
+          GRANT ALL ON ALL FUNCTIONS IN SCHEMA PUBLIC TO PUBLIC;\
+          GRANT ALL ON ALL SEQUENCES IN SCHEMA PUBLIC TO PUBLIC;"
+          shell(cmd_acl,true)
+        end
+      end
+      
+      def drop(collection_or_table_names=nil)
+        if is_postgresql
+          sel_tables = "SELECT table_name FROM information_schema.tables WHERE table_schema='public'"
+          if collection_or_table_names
+            sel_tables = "#{sel_tables} AND table_name LIKE '#{collection_or_table_names}'"
+          end
+          tables = shell(sel_tables)
+          tables_arr = Array.new
+          tables.split("\n").each do | line |
+            line.strip!
+            tables_arr << line if line
+          end
+          if tables_arr.size > 0 && ask("Delete the tables \"#{tables_arr.join(',')}\"?", :default => true)
+            #let's create a file in case there are a lot of tables:
+            file = Tempfile.new('droptables')
+            begin
+              File.open(file.path, 'w') do |f2|
+                tables_arr.each do |table|
+                  f2.puts "DROP TABLE public.#{table} CASCADE;"
+                end
+              end
+              puts shell(file.path)
+            ensure
+              file.unlink   # deletes the temp file
+            end
+          end
+          puts "Vacuum orphaned large objects..."
+          cmd = VMC::KNIFE.pg_connect_cmd(credentials(), 'vacuumlo')
+          puts cmd
+          puts `#{cmd}`
+        elsif is_mongodb
+          #TODO: iterate over the collections and drop them according to the filter.
+          raise "TODO: Unsupported operation 'drop' for the data-service #{name()}"
+        else
+          puts "Unsupported operation 'drop' for the data-service #{name()}"
+        end
+      end
+                                                                                                                                        
+    end
+    
+  end
+end

data/lib/vmc_knife/vmc_knife.rb

@@ -197,12 +197,13 @@ module VMC
     end
     
     class RecipesConfigurationApplier
-      attr_accessor :root, :client, :applications, :recipes, :data_services
+      attr_accessor :root, :client, :applications, :recipes, :data_services, :opts
       # Select the applications and data-services to configure according to the values
       # in the SaaS manifest. When the selector is nil all of them are selected.
-      def initialize(manifest, client, recipe_sel=nil, application_sel=nil, service_sel=nil)
+      def initialize(manifest, client, recipe_sel=nil, application_sel=nil, service_sel=nil, opts=nil)
         @root = Root.new manifest
         @client = client
+        @opts=opts
         @recipes = @root.recipes(recipe_sel)
         @applications = Array.new
         @data_services = Array.new
@@ -210,6 +211,14 @@ module VMC
           @applications = @applications + recipe.applications(application_sel)
           @data_services = @data_services + recipe.data_services(service_sel)
         end
+        app_names = @applications.collect {|app| app.name }
+        service_names = @data_services.collect {|service| service.name }
+        if app_names.empty? && service_names.empty?
+          puts "No applications and data-services were selected."
+        else
+          puts "Applications selected #{app_names.join(', ')}" unless app_names.empty?
+          puts "Data-services selected #{service_names.join(', ')}" unless service_names.empty?
+        end
       end
       # Only for testing: inject json
       def __set_current(current_services=nil,current_services_info=nil)
@@ -427,17 +436,38 @@ module VMC
             if Dir.entries(Dir.pwd).size == 2
               puts "Dir.entries(#{Dir.pwd}).size #{Dir.entries(Dir.pwd).size}"
               #empty directory.
-              `wget --output-document=_download_.zip #{url}`
-              raise "Unable to download #{url}" unless $? == 0
-              if /\.tgz$/ =~ url || /\.tar\.gz$/ =~ url
-                `tar zxvf _download_.zip`
-              elsif /\.tar$/ =~ url
-                `tar xvf _download_.zip`
+              if /\.git$/ =~ url
+                `git clone #{url} --depth 1`
+                branch = @application_json['repository']['branch']
+                if branch
+                  `git checkout #{branch}`
+                else
+                  branch=master
+                end
+                `git pull origin #{branch}`
               else
-                `unzip _download_.zip`
+                wget_args = @application_json['repository']['wget_args']
+                if wget_args.nil?
+                  wget_args_str = ""
+                elsif wget_args.kind_of? Array
+                  wget_args_str = wget_args.join(' ')
+                elsif wget_args.kind_of? String
+                  wget_args_str = wget_args
+                end
+                `wget #{wget_args_str} --output-document=_download_.zip #{url}`
+                raise "Unable to download #{url}" unless $? == 0
+                if /\.tgz$/ =~ url || /\.tar\.gz$/ =~ url
+                  `tar zxvf _download_.zip`
+                elsif /\.tar$/ =~ url
+                  `tar xvf _download_.zip`
+                else
+                  `unzip _download_.zip`
+                end
+                `rm _download_.zip`
               end
-              `rm _download_.zip`
             end
+            Dir.chdir(@application_json['repository']['sub_dir']) if @application_json['repository']['sub_dir']
+            `rm -rf .git` if File.exists? ".git"
             VMC::KNIFE::HELPER.static_upload_app_bits(@client,@application_json['name'],Dir.pwd)
           end
         end
@@ -494,7 +524,7 @@ module VMC
         updates = Hash.new
         updates['name'] = name if name
         updates['services'] = services if services
-        updates['env'] = services if services
+        updates['env'] = env if env
         updates['uris'] = uris if uris
         updates['memory'] = memory if memory
         updates unless updates.empty?

data/lib/vmc_knife.rb

@@ -18,5 +18,6 @@ end
 require "#{ROOT_REL}/vmc_knife/json_expander"
 require "#{ROOT_REL}/vmc_knife/vmc_helper"
 require "#{ROOT_REL}/vmc_knife/vmc_knife"
+require "#{ROOT_REL}/vmc_knife/data_services"
 
 require "#{ROOT_REL}/vmc_knife/cli_extensions"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: vmc_knife
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Intalio Pte
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-06 00:00:00 Z
+date: 2011-12-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: vmc
@@ -106,6 +106,7 @@ files:
 - lib/restclient/restclient_add_timeout.rb
 - lib/vmc_knife/cli_extensions.rb
 - lib/vmc_knife/commands/knife_cmds.rb
+- lib/vmc_knife/data_services.rb
 - lib/vmc_knife/json_expander.rb
 - lib/vmc_knife/version.rb
 - lib/vmc_knife/vmc_helper.rb