(FM-2577) - Change from sqlcmd.exe to win32ole connector

.fixtures.yml

@@ -2,5 +2,6 @@ fixtures:
   forge_modules:
     acl: "puppetlabs/acl"
     stdlib: "puppetlabs/stdlib"
+    acl: "puppetlabs/acl"
   symlinks:
-    "sqlserver": "#{source_dir}"
+    sqlserver: "#{source_dir}"

.travis.yml

@@ -1,10 +1,12 @@
 ---
+sudo: false
 language: ruby
 bundler_args: --without development
 script: "bundle exec rake spec SPEC_OPTS='--format documentation'"
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.5  
 env:
   matrix:
     - PUPPET_GEM_VERSION="~> 3.7.1"

README.md

@@ -95,6 +95,39 @@ sqlserver::login{'WIN-D95P1A3V103\localAccount':
 }
 ```
 
+###To run custom TSQL statements:
+
+To use `sqlserver_tsql` to trigger other classes or defined types:
+
+```
+sqlserver_tsql{ 'Query Logging DB Status':
+    instance => 'MSSQLSERVER',
+    onlyif   => "IF (SELECT count(*) FROM myDb.dbo.logging_table WHERE
+        message like 'FATAL%') > 1000  THROW 50000, 'Fatal Exceptions in Logging', 10",
+    notify   => Exec['Too Many Fatal Errors']
+}  
+```
+
+To clean up regular logs with conditional checks:
+
+```
+sqlserver_tsql{ 'Cleanup Old Logs':
+    instance => 'MSSQLSERVER',
+    command  => "DELETE FROM myDb.dbo.logging_table WHERE log_date < '${log_max_date}'",
+    onlyif   => "IF exists(SELECT * FROM myDb.dbo.logging_table WHERE log_date < '${log_max_date}')
+        THROW 50000, 'need log cleanup', 10",
+}
+```
+
+If you want something to always execute, you can leave out the `onlyif` parameter:
+
+```
+sqlserver_tsql{ 'Always running':
+    instance => 'MSSQLSERVER',
+    command  => 'EXEC notified_executor()',
+}
+```
+
 #### Windows SQL Server Terms
 
 Terminology differs somewhat between various database systems; please refer to this list of terms for clarification.

lib/puppet/parser/functions/sqlserver_upcase.rb

@@ -0,0 +1,28 @@
+module Puppet::Parser::Functions
+  newfunction(:sqlserver_upcase, :type => :rvalue, :arity => 1) do |arguments|
+
+    raise(Puppet::ParseError, "upcase(): Wrong number of arguments " +
+                              "given (#{arguments.size} for 1)") if arguments.size != 1
+
+    value = arguments[0]
+
+    unless value.is_a?(Array) || value.is_a?(Hash) || value.respond_to?(:upcase)
+      raise(Puppet::ParseError, 'upcase(): Requires an ' +
+                                'array, hash or object that responds to upcase in order to work')
+    end
+
+    if value.is_a?(Array)
+      # Numbers in Puppet are often string-encoded which is troublesome ...
+      result = value.collect { |i| function_sqlserver_upcase([i]) }
+    elsif value.is_a?(Hash)
+      result = {}
+      value.each_pair do |k, v|
+        result[function_sqlserver_upcase([k])] = function_sqlserver_upcase([v])
+      end
+    else
+      result = value.upcase
+    end
+
+    return result
+  end
+end

lib/puppet/parser/functions/sqlserver_validate_hash_uniq_values.rb

@@ -0,0 +1,21 @@
+# === Defined Parser Function: sqlserver_validate_hash_uniq_values
+#
+# [args*] A hash, that contains string or string[] for values
+#
+# @raise [Puppet::ParserError] When duplicates are found
+#
+module Puppet::Parser::Functions
+  newfunction(:sqlserver_validate_hash_uniq_values) do |arguments|
+
+    raise(Puppet::ParseError, 'Expect a Hash as an argument') unless arguments[0].is_a?(Hash)
+
+    value = arguments[0].each_value.collect { |v| v }.flatten
+
+    total_count = value.count
+    uniq_count = value.uniq.count
+    msg = arguments[1] ? arguments[1] : "Duplicate values passed to hash #{value}"
+    if uniq_count != total_count
+      raise(Puppet::ParseError, msg)
+    end
+  end
+end

lib/puppet/parser/functions/sqlserver_validate_instance_name.rb

@@ -20,6 +20,9 @@ module Puppet::Parser::Functions
     end
     value = args[0]
     errors = []
+    if value.length < 1 || value.empty?
+      errors << "Instance name must be between 1 to 16 characters"
+    end
     if value.length > 16
       errors << "Instance name can not be larger than 16 characters, you provided #{value}"
     end

lib/puppet/parser/functions/sqlserver_validate_range.rb

@@ -3,15 +3,21 @@ module Puppet::Parser::Functions
     if (args.length < 3) or (args.length > 4) then
       raise Puppet::ParseError, ("validate_range(): wrong number of arguments (#{args.length}; must be 3)")
     end
-    value, lower, upper, msg = args
+    values, lower, upper, msg = args
 
-    msg = msg || "validate_range(): #{args[0].inspect} is not between #{args[1].inspect} and #{args[2].inspect}"
 
-    if /^\d+(|\.\d+)$/.match(value)
-      raise(Puppet::ParseError, msg) unless Float(value).between?(Float(lower), Float(upper))
-    else
-      value.strip!
-      raise(Puppet::ParseError, msg) unless value.length >= Integer(lower) && value.length <= Integer(upper)
+    if values.is_a? String
+      values = Array.new << values
+    end
+
+    values.each do |value|
+      msg = msg || "validate_range(): #{args[0].inspect} is not between #{args[1].inspect} and #{args[2].inspect}"
+      if /^\d+(|\.\d+)$/.match(value)
+        raise(Puppet::ParseError, msg) unless Float(value).between?(Float(lower), Float(upper))
+      else
+        value.strip!
+        raise(Puppet::ParseError, msg) unless value.length >= Integer(lower) && value.length <= Integer(upper)
+      end
     end
   end
 end

lib/puppet/property/sqlserver_tsql.rb

@@ -0,0 +1,19 @@
+require 'puppet/property'
+
+class Puppet::Property::SqlserverTsql < Puppet::Property
+  desc 'TSQL property that we are going to wrap with a try catch'
+  munge do |value|
+    erb_template = <<-TEMPLATE
+BEGIN TRY
+    #{value}
+END TRY
+BEGIN CATCH
+    DECLARE @msg as VARCHAR(max);
+    SELECT @msg = 'THROW CAUGHT: ' + ERROR_MESSAGE();
+    THROW 51000, @msg, 10
+END CATCH
+    TEMPLATE
+    value = erb_template
+  end
+
+end

lib/puppet/provider/sqlserver.rb

@@ -51,8 +51,15 @@ def self.run_authenticated_sqlcmd(query, opts)
         temp_ps1.write(ps1.result(b))
         temp_ps1.flush
         temp_ps1.close
+        #We want to not fail the exec but fail the overall process once we get the clean result back, otherwise we report the temp file which is meaningless
         result = Puppet::Util::Execution.execute(['powershell.exe', '-noprofile', '-executionpolicy', 'unrestricted', temp_ps1.path], {:failonfail => false}) #We expect some things to fail in order to run as an only if
-        debug("Return result #{result.exitstatus}")
+        debug("Return result #{result}")
+        if opts[:failonfail] && result.match(/THROW CAUGHT/)
+          fail(result.gsub('THROW CAUGHT:', ''))
+        end
+        if result.match(/Msg \d+, Level 16/)
+          fail(result)
+        end
         return result
       ensure
         temp_ps1.close

lib/puppet/provider/sqlserver_tsql/mssql.rb

@@ -1,21 +1,61 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'sqlserver'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'puppet_x/sqlserver/sql_connection'))
 
 Puppet::Type::type(:sqlserver_tsql).provide(:mssql, :parent => Puppet::Provider::Sqlserver) do
 
+
   def run(query)
     debug("Running resource #{query} against #{resource[:instance]}")
-    result = Puppet::Provider::Sqlserver.run_authenticated_sqlcmd(query, {:instance_name => resource[:instance]})
-    return result
+    config = get_instance_config
+    begin
+      sqlconn = PuppetX::Sqlserver::SqlConnection.new
+      sqlconn.open(config["admin"], config["pass"], resource[:instance])
+      sqlconn.command(query)
+      result = ResultOutput.new(sqlconn)
+      if result.has_errors
+        debug("Returned a result of #{result.exitstatus}, with #{parse_for_error(result.error_message)}")
+      end
+      return result
+    ensure
+      sqlconn.close
+    end
+  end
+
+  def get_instance_config
+    config_file = File.join(Puppet[:vardir], "cache/sqlserver/.#{resource[:instance]}.cfg")
+    if !File.exists? (config_file)
+      fail('Required config file missing, add the appropriate sqlserver::config and rerun')
+    end
+    if !File.readable?(config_file)
+      fail('Unable to read config file, ensure proper permissions and please try again')
+    end
+    JSON.parse(File.read(config_file))
   end
 
   def run_check
-    result = self.run(resource[:onlyif])
-    return result
+    return self.run(resource[:onlyif])
   end
 
   def run_update
-    result = self.run(resource[:command])
-    return result
+    return self.run(resource[:command])
+
   end
 
+  def parse_for_error(result)
+    match = result.match(/SQL Server\n\s+(.*)/i)
+    match[1] unless match == nil
+  end
+
+  class ResultOutput
+    attr_reader :exitstatus, :error_message
+
+    def initialize(sqlconn)
+      @exitstatus = sqlconn.has_errors ? 1 : 0
+      @error_message = sqlconn.error_message
+    end
+
+    def has_errors
+      @exitstatus != 0
+    end
+  end
 end

lib/puppet/templates/authenticated_query.ps1.erb

@@ -24,14 +24,22 @@ if (!(Get-Command 'sqlcmd.exe' -ErrorAction SilentlyContinue)){
 }
 
 $result = sqlcmd.exe -i '<%= input_file %>' -h-1 -W -s ',' <% if @instance != 'MSSQLSERVER' %>-S localhost\<%= @instance %><%end%>
-    if($result -match "ERROR"){
-        Write-Error -Message ($result | where {$_ -match "ERROR"} | select -First 1)
+    if($result -match "THROW CAUGHT"){
+    	Write-Host ($result | where {$_ -match "THROW CAUGHT"} | select -First 1)
+        Write-Error -Message ($result | where {$_ -match "THROW CAUGHT"} | select -First 1)
 		exit(10)
     }
 	if($result -match "Incorrect syntax near "){
+		Write-Host ($result | where {$_ -match "Incorrect syntax near"} | select -First 1)
 	    Write-Error -Message ($result | where {$_ -match "Incorrect syntax"} | select -First 1)
 		exit(10)
 	}
+	if($result -match "Msg \d+, Level 16"){
+		$msg = $result -join ' '
+		Write-Host $msg
+		Write-Error -Message "ERROR: $msg"
+		exit(10)
+	}
 }
 catch{
 	Write-Host $_

lib/puppet/type/sqlserver_features.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'property/login'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'property/sqlserver_login'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'puppet_x/sqlserver/server_helper'))
 
 Puppet::Type::newtype(:sqlserver_features) do

lib/puppet/type/sqlserver_instance.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'property/login'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'property/sqlserver_login'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'puppet_x/sqlserver/server_helper'))
 
 Puppet::Type::newtype(:sqlserver_instance) do

lib/puppet/type/sqlserver_tsql.rb

@@ -1,4 +1,5 @@
 require 'puppet'
+require 'puppet/property/sqlserver_tsql'
 
 Puppet::Type::newtype(:sqlserver_tsql) do
   newparam :name, :namevar => true
@@ -15,21 +16,23 @@ def self.checks
   end
 
   desc 'command to run against an instance with the authenticated credentials used in sqlserver::config'
-  newparam(:command) do
+  newparam(:command, :parent => Puppet::Property::SqlserverTsql) do
 
   end
 
   desc 'requires the usage of sqlserver::config with the user and password'
   newparam(:instance) do
-
+    munge do |value|
+      value.upcase
+    end
   end
 
   desc 'SQL Query to run and only run if exits with non-zero'
-  newcheck(:onlyif) do
-    # Return true if the command returns 0.
+  newcheck(:onlyif, :parent => Puppet::Property::SqlserverTsql) do
+    #Runs in the event that our TSQL exits with anything other than 0
     def check(value)
       begin
-        output = provider.run(value)
+        output = provider.run(value, :failonfail => false)
       end
       debug("OnlyIf returned exitstatus of #{output.exitstatus}")
       output.exitstatus != 0
@@ -58,7 +61,10 @@ def output
 
   def refresh
     if self.check_all_attributes(true)
-      provider.run_update
+      result = provider.run_update
+      if result.has_errors
+        fail("Unable to apply changes, failed with error message #{result.error_message}")
+      end
     end
   end