pghero 2.8.3 → 3.3.3

data/lib/pghero/methods/suggested_indexes.rb

@@ -2,7 +2,7 @@ module PgHero
   module Methods
     module SuggestedIndexes
       def suggested_indexes_enabled?
-        defined?(PgQuery) && Gem::Version.new(PgQuery::VERSION) >= Gem::Version.new("0.9.0") && query_stats_enabled?
+        defined?(PgQuery) && Gem::Version.new(PgQuery::VERSION) >= Gem::Version.new("2") && query_stats_enabled?
       end
 
       # TODO clean this mess
@@ -79,7 +79,7 @@ module PgHero
         suggested_indexes.each do |index|
           p index
           if create
-            connection.execute("CREATE INDEX CONCURRENTLY ON #{quote_table_name(index[:table])} (#{index[:columns].map { |c| quote_table_name(c) }.join(",")})")
+            connection.execute("CREATE INDEX CONCURRENTLY ON #{quote_table_name(index[:table])} (#{index[:columns].map { |c| quote_column_name(c) }.join(",")})")
           end
         end
       end
@@ -104,7 +104,7 @@ module PgHero
         # TODO get schema from query structure, then try search path
         schema = PgHero.connection_config(connection_model)[:schema] || "public"
         if tables.any?
-          row_stats = Hash[table_stats(table: tables, schema: schema).map { |i| [i[:table], i[:estimated_rows]] }]
+          row_stats = table_stats(table: tables, schema: schema).to_h { |i| [i[:table], i[:estimated_rows]] }
           col_stats = column_stats(table: tables, schema: schema).group_by { |i| i[:table] }
         end
 
@@ -126,7 +126,7 @@ module PgHero
             total_rows = row_stats[table].to_i
             index[:rows] = total_rows
 
-            ranks = Hash[col_stats[table].to_a.map { |r| [r[:column], r] }]
+            ranks = col_stats[table].to_a.to_h { |r| [r[:column], r] }
             columns = (where + sort).map { |c| c[:column] }.uniq
 
             if columns.any?
@@ -135,7 +135,7 @@ module PgHero
                 sort = sort.first(first_desc + 1) if first_desc
                 where = where.sort_by { |c| [row_estimates(ranks[c[:column]], total_rows, total_rows, c[:op]), c[:column]] } + sort
 
-                index[:row_estimates] = Hash[where.map { |c| ["#{c[:column]} (#{c[:op] || "sort"})", row_estimates(ranks[c[:column]], total_rows, total_rows, c[:op]).round] }]
+                index[:row_estimates] = where.to_h { |c| ["#{c[:column]} (#{c[:op] || "sort"})", row_estimates(ranks[c[:column]], total_rows, total_rows, c[:op]).round] }
 
                 # no index needed if less than 500 rows
                 if total_rows >= 500
@@ -194,6 +194,7 @@ module PgHero
       end
 
       def best_index_structure(statement)
+        return {error: "Empty statement"} if statement.to_s.empty?
         return {error: "Too large"} if statement.to_s.length > 10000
 
         begin
@@ -202,68 +203,33 @@ module PgHero
           return {error: "Parse error"}
         end
 
-        if PgQuery::VERSION.to_i >= 2
-          return {error: "Unknown structure"} unless tree.stmts.size == 1
-
-          tree = tree.stmts.first.stmt
-
-          table = parse_table_v2(tree) rescue nil
-          unless table
-            error =
-              case tree.node
-              when :insert_stmt
-                "INSERT statement"
-              when :variable_set_stmt
-                "SET statement"
-              when :select_stmt
-                if (tree.select_stmt.from_clause.first.join_expr rescue false)
-                  "JOIN not supported yet"
-                end
+        return {error: "Unknown structure"} unless tree.stmts.size == 1
+
+        tree = tree.stmts.first.stmt
+
+        table = parse_table(tree) rescue nil
+        unless table
+          error =
+            case tree.node
+            when :insert_stmt
+              "INSERT statement"
+            when :variable_set_stmt
+              "SET statement"
+            when :select_stmt
+              if (tree.select_stmt.from_clause.first.join_expr rescue false)
+                "JOIN not supported yet"
               end
-            return {error: error || "Unknown structure"}
-          end
-
-          select = tree[tree.node.to_s]
-          where = (select.where_clause ? parse_where_v2(select.where_clause) : []) rescue nil
-          return {error: "Unknown structure"} unless where
-
-          sort = (select.sort_clause ? parse_sort_v2(select.sort_clause) : []) rescue []
-
-          {table: table, where: where, sort: sort}
-        else
-          # TODO remove support for pg_query < 2 in PgHero 3.0
-
-          return {error: "Unknown structure"} unless tree.size == 1
-
-          tree = tree.first
-
-          # pg_query 1.0.0
-          tree = tree["RawStmt"]["stmt"] if tree["RawStmt"]
-
-          table = parse_table(tree) rescue nil
-          unless table
-            error =
-              case tree.keys.first
-              when "InsertStmt"
-                "INSERT statement"
-              when "VariableSetStmt"
-                "SET statement"
-              when "SelectStmt"
-                if (tree["SelectStmt"]["fromClause"].first["JoinExpr"] rescue false)
-                  "JOIN not supported yet"
-                end
-              end
-            return {error: error || "Unknown structure"}
-          end
+            end
+          return {error: error || "Unknown structure"}
+        end
 
-          select = tree.values.first
-          where = (select["whereClause"] ? parse_where(select["whereClause"]) : []) rescue nil
-          return {error: "Unknown structure"} unless where
+        select = tree[tree.node.to_s]
+        where = (select.where_clause ? parse_where(select.where_clause) : []) rescue nil
+        return {error: "Unknown structure"} unless where
 
-          sort = (select["sortClause"] ? parse_sort(select["sortClause"]) : []) rescue []
+        sort = (select.sort_clause ? parse_sort(select.sort_clause) : []) rescue []
 
-          {table: table, where: where, sort: sort}
-        end
+        {table: table, where: where, sort: sort}
       end
 
       # TODO better row estimation
@@ -300,7 +266,7 @@ module PgHero
         end
       end
 
-      def parse_table_v2(tree)
+      def parse_table(tree)
         case tree.node
         when :select_stmt
           tree.select_stmt.from_clause.first.range_var.relname
@@ -311,77 +277,41 @@ module PgHero
         end
       end
 
-      def parse_table(tree)
-        case tree.keys.first
-        when "SelectStmt"
-          tree["SelectStmt"]["fromClause"].first["RangeVar"]["relname"]
-        when "DeleteStmt"
-          tree["DeleteStmt"]["relation"]["RangeVar"]["relname"]
-        when "UpdateStmt"
-          tree["UpdateStmt"]["relation"]["RangeVar"]["relname"]
-        end
-      end
-
       # TODO capture values
-      def parse_where_v2(tree)
+      def parse_where(tree)
         aexpr = tree.a_expr
 
         if tree.bool_expr
           if tree.bool_expr.boolop == :AND_EXPR
-            tree.bool_expr.args.flat_map { |v| parse_where_v2(v) }
+            tree.bool_expr.args.flat_map { |v| parse_where(v) }
           else
             raise "Not Implemented"
           end
-        elsif aexpr && ["=", "<>", ">", ">=", "<", "<=", "~~", "~~*", "BETWEEN"].include?(aexpr.name.first.string.str)
-          [{column: aexpr.lexpr.column_ref.fields.last.string.str, op: aexpr.name.first.string.str}]
+        elsif aexpr && ["=", "<>", ">", ">=", "<", "<=", "~~", "~~*", "BETWEEN"].include?(aexpr.name.first.string.send(str_method))
+          [{column: aexpr.lexpr.column_ref.fields.last.string.send(str_method), op: aexpr.name.first.string.send(str_method)}]
         elsif tree.null_test
           op = tree.null_test.nulltesttype == :IS_NOT_NULL ? "not_null" : "null"
-          [{column: tree.null_test.arg.column_ref.fields.last.string.str, op: op}]
+          [{column: tree.null_test.arg.column_ref.fields.last.string.send(str_method), op: op}]
         else
           raise "Not Implemented"
         end
       end
 
-      # TODO capture values
-      def parse_where(tree)
-        aexpr = tree["A_Expr"]
-
-        if tree["BoolExpr"]
-          if tree["BoolExpr"]["boolop"] == 0
-            tree["BoolExpr"]["args"].flat_map { |v| parse_where(v) }
-          else
-            raise "Not Implemented"
-          end
-        elsif aexpr && ["=", "<>", ">", ">=", "<", "<=", "~~", "~~*", "BETWEEN"].include?(aexpr["name"].first["String"]["str"])
-          [{column: aexpr["lexpr"]["ColumnRef"]["fields"].last["String"]["str"], op: aexpr["name"].first["String"]["str"]}]
-        elsif tree["NullTest"]
-          op = tree["NullTest"]["nulltesttype"] == 1 ? "not_null" : "null"
-          [{column: tree["NullTest"]["arg"]["ColumnRef"]["fields"].last["String"]["str"], op: op}]
-        else
-          raise "Not Implemented"
-        end
-      end
-
-      def parse_sort_v2(sort_clause)
-        sort_clause.map do |v|
-          {
-            column: v.sort_by.node.column_ref.fields.last.string.str,
-            direction: v.sort_by.sortby_dir == :SORTBY_DESC ? "desc" : "asc"
-          }
-        end
+      def str_method
+        @str_method ||= Gem::Version.new(PgQuery::VERSION) >= Gem::Version.new("4") ? :sval : :str
       end
 
       def parse_sort(sort_clause)
         sort_clause.map do |v|
           {
-            column: v["SortBy"]["node"]["ColumnRef"]["fields"].last["String"]["str"],
-            direction: v["SortBy"]["sortby_dir"] == 2 ? "desc" : "asc"
+            column: v.sort_by.node.column_ref.fields.last.string.send(str_method),
+            direction: v.sort_by.sortby_dir == :SORTBY_DESC ? "desc" : "asc"
           }
         end
       end
 
       def column_stats(schema: nil, table: nil)
-        select_all <<-SQL
+        select_all <<~SQL
           SELECT
             schemaname AS schema,
             tablename AS table,

data/lib/pghero/methods/system.rb

@@ -5,9 +5,8 @@ module PgHero
         !system_stats_provider.nil?
       end
 
-      # TODO remove defined checks in 3.0
       def system_stats_provider
-        if aws_db_instance_identifier && (defined?(Aws) || defined?(AWS))
+        if aws_db_instance_identifier
           :aws
         elsif gcp_database_id
           :gcp
@@ -42,18 +41,13 @@ module PgHero
 
       def rds_stats(metric_name, duration: nil, period: nil, offset: nil, series: false)
         if system_stats_enabled?
-          aws_options = {region: region}
-          if access_key_id
-            aws_options[:access_key_id] = access_key_id
-            aws_options[:secret_access_key] = secret_access_key
+          aws_options = {region: aws_region}
+          if aws_access_key_id
+            aws_options[:access_key_id] = aws_access_key_id
+            aws_options[:secret_access_key] = aws_secret_access_key
           end
 
-          client =
-            if defined?(Aws)
-              Aws::CloudWatch::Client.new(aws_options)
-            else
-              AWS::CloudWatch.new(aws_options).client
-            end
+          client = Aws::CloudWatch::Client.new(aws_options)
 
           duration = (duration || 1.hour).to_i
           period = (period || 1.minute).to_i
@@ -108,7 +102,8 @@ module PgHero
           end
 
         client = Azure::Monitor::Profiles::Latest::Mgmt::Client.new
-        timespan = "#{start_time.iso8601}/#{end_time.iso8601}"
+        # call utc to convert +00:00 to Z
+        timespan = "#{start_time.utc.iso8601}/#{end_time.utc.iso8601}"
         results = client.metrics.list(
           azure_resource_id,
           metricnames: metric_name,
@@ -275,12 +270,13 @@ module PgHero
             used = azure_stats("storage_used", **options)
             free_space(quota, used)
           else
-            # no read_iops, write_iops
-            # could add io_consumption_percent
+            replication_lag_stat = azure_flexible_server? ? "physical_replication_delay_in_seconds" : "pg_replica_log_delay_in_seconds"
             metrics = {
               cpu: "cpu_percent",
               connections: "active_connections",
-              replication_lag: "pg_replica_log_delay_in_seconds"
+              replication_lag: replication_lag_stat,
+              read_iops: "read_iops", # flexible server only
+              write_iops: "write_iops" # flexible server only
             }
             raise Error, "Metric not supported" unless metrics[metric_key]
             azure_stats(metrics[metric_key], **options)
@@ -290,6 +286,10 @@ module PgHero
         end
       end
 
+      def azure_flexible_server?
+        azure_resource_id.include?("/Microsoft.DBforPostgreSQL/flexibleServers/")
+      end
+
       # only use data points included in both series
       # this also eliminates need to align Time.now
       def free_space(quota, used)

data/lib/pghero/methods/tables.rb

@@ -2,17 +2,16 @@ module PgHero
   module Methods
     module Tables
       def table_hit_rate
-        select_one(<<-SQL
+        select_one <<~SQL
           SELECT
             sum(heap_blks_hit) / nullif(sum(heap_blks_hit) + sum(heap_blks_read), 0) AS rate
           FROM
             pg_statio_user_tables
         SQL
-        )
       end
 
       def table_caching
-        select_all <<-SQL
+        select_all <<~SQL
           SELECT
             schemaname AS schema,
             relname AS table,
@@ -29,7 +28,7 @@ module PgHero
       end
 
       def unused_tables
-        select_all <<-SQL
+        select_all <<~SQL
           SELECT
             schemaname AS schema,
             relname AS table,
@@ -45,7 +44,7 @@ module PgHero
       end
 
       def table_stats(schema: nil, table: nil)
-        select_all <<-SQL
+        select_all <<~SQL
           SELECT
             nspname AS schema,
             relname AS table,

data/lib/pghero/methods/users.rb

@@ -2,11 +2,15 @@ module PgHero
   module Methods
     module Users
       # documented as unsafe to pass user input
-      # TODO quote in 3.0, but still not officially supported
+      # identifiers are now quoted, but still not officially supported
       def create_user(user, password: nil, schema: "public", database: nil, readonly: false, tables: nil)
         password ||= random_password
         database ||= PgHero.connection_config(connection_model)[:database]
 
+        user = quote_ident(user)
+        schema = quote_ident(schema)
+        database = quote_ident(database)
+
         commands =
           [
             "CREATE ROLE #{user} LOGIN PASSWORD #{quote(password)}",
@@ -42,10 +46,14 @@ module PgHero
       end
 
       # documented as unsafe to pass user input
-      # TODO quote in 3.0, but still not officially supported
+      # identifiers are now quoted, but still not officially supported
       def drop_user(user, schema: "public", database: nil)
         database ||= PgHero.connection_config(connection_model)[:database]
 
+        user = quote_ident(user)
+        schema = quote_ident(schema)
+        database = quote_ident(database)
+
         # thanks shiftb
         commands =
           [
@@ -77,9 +85,9 @@ module PgHero
         SecureRandom.base64(40).delete("+/=")[0...24]
       end
 
-      def table_grant_commands(privilege, tables, user)
+      def table_grant_commands(privilege, tables, quoted_user)
         tables.map do |table|
-          "GRANT #{privilege} ON TABLE #{table} TO #{user}"
+          "GRANT #{privilege} ON TABLE #{quote_ident(table)} TO #{quoted_user}"
         end
       end
     end

data/lib/pghero/version.rb

@@ -1,3 +1,3 @@
 module PgHero
-  VERSION = "2.8.3"
+  VERSION = "3.3.3"
 end

data/lib/pghero.rb

@@ -1,29 +1,31 @@
 # dependencies
 require "active_support"
+
+# stdlib
 require "forwardable"
 
 # methods
-require "pghero/methods/basic"
-require "pghero/methods/connections"
-require "pghero/methods/constraints"
-require "pghero/methods/explain"
-require "pghero/methods/indexes"
-require "pghero/methods/kill"
-require "pghero/methods/maintenance"
-require "pghero/methods/queries"
-require "pghero/methods/query_stats"
-require "pghero/methods/replication"
-require "pghero/methods/sequences"
-require "pghero/methods/settings"
-require "pghero/methods/space"
-require "pghero/methods/suggested_indexes"
-require "pghero/methods/system"
-require "pghero/methods/tables"
-require "pghero/methods/users"
-
-require "pghero/database"
-require "pghero/engine" if defined?(Rails)
-require "pghero/version"
+require_relative "pghero/methods/basic"
+require_relative "pghero/methods/connections"
+require_relative "pghero/methods/constraints"
+require_relative "pghero/methods/explain"
+require_relative "pghero/methods/indexes"
+require_relative "pghero/methods/kill"
+require_relative "pghero/methods/maintenance"
+require_relative "pghero/methods/queries"
+require_relative "pghero/methods/query_stats"
+require_relative "pghero/methods/replication"
+require_relative "pghero/methods/sequences"
+require_relative "pghero/methods/settings"
+require_relative "pghero/methods/space"
+require_relative "pghero/methods/suggested_indexes"
+require_relative "pghero/methods/system"
+require_relative "pghero/methods/tables"
+require_relative "pghero/methods/users"
+
+require_relative "pghero/database"
+require_relative "pghero/engine" if defined?(Rails)
+require_relative "pghero/version"
 
 module PgHero
   autoload :Connection, "pghero/connection"
@@ -53,15 +55,15 @@ module PgHero
 
   class << self
     extend Forwardable
-    def_delegators :primary_database, :access_key_id, :analyze, :analyze_tables, :autoindex, :autovacuum_danger,
+    def_delegators :primary_database, :aws_access_key_id, :analyze, :analyze_tables, :autoindex, :autovacuum_danger,
       :best_index, :blocked_queries, :connections, :connection_sources, :connection_states, :connection_stats,
-      :cpu_usage, :create_user, :database_size, :db_instance_identifier, :disable_query_stats, :drop_user,
+      :cpu_usage, :create_user, :database_size, :aws_db_instance_identifier, :disable_query_stats, :drop_user,
       :duplicate_indexes, :enable_query_stats, :explain, :historical_query_stats_enabled?, :index_caching,
       :index_hit_rate, :index_usage, :indexes, :invalid_constraints, :invalid_indexes, :kill, :kill_all, :kill_long_running_queries,
       :last_stats_reset_time, :long_running_queries, :maintenance_info, :missing_indexes, :query_stats,
       :query_stats_available?, :query_stats_enabled?, :query_stats_extension_enabled?, :query_stats_readable?,
-      :rds_stats, :read_iops_stats, :region, :relation_sizes, :replica?, :replication_lag, :replication_lag_stats,
-      :reset_query_stats, :reset_stats, :running_queries, :secret_access_key, :sequence_danger, :sequences, :settings,
+      :rds_stats, :read_iops_stats, :aws_region, :relation_sizes, :replica?, :replication_lag, :replication_lag_stats,
+      :reset_query_stats, :reset_stats, :running_queries, :aws_secret_access_key, :sequence_danger, :sequences, :settings,
       :slow_queries, :space_growth, :ssl_used?, :stats_connection, :suggested_indexes, :suggested_indexes_by_query,
       :suggested_indexes_enabled?, :system_stats_enabled?, :table_caching, :table_hit_rate, :table_stats,
       :total_connections, :transaction_id_danger, :unused_indexes, :unused_tables, :write_iops_stats
@@ -86,12 +88,32 @@ module PgHero
       @password ||= config["password"] || ENV["PGHERO_PASSWORD"]
     end
 
+    # config pattern for https://github.com/ankane/pghero/issues/424
     def stats_database_url
-      @stats_database_url ||= config["stats_database_url"] || ENV["PGHERO_STATS_DATABASE_URL"]
+      @stats_database_url ||= (file_config || {})["stats_database_url"] || ENV["PGHERO_STATS_DATABASE_URL"]
+    end
+
+    # private
+    def explain_enabled?
+      explain_mode.nil? || explain_mode == true || explain_mode == "analyze"
+    end
+
+    # private
+    def explain_mode
+      @config["explain"]
+    end
+
+    def visualize_url
+      @visualize_url ||= config["visualize_url"] || ENV["PGHERO_VISUALIZE_URL"] || "https://tatiyants.com/pev/#/plans/new"
     end
 
     def config
-      @config ||= begin
+      @config ||= file_config || default_config
+    end
+
+    # private
+    def file_config
+      unless defined?(@file_config)
         require "erb"
         require "yaml"
 
@@ -99,43 +121,51 @@ module PgHero
 
         config_file_exists = File.exist?(path)
 
-        config = YAML.load(ERB.new(File.read(path)).result) if config_file_exists
+        config = YAML.safe_load(ERB.new(File.read(path)).result) if config_file_exists
         config ||= {}
 
-        if config[env]
-          config[env]
-        elsif config["databases"] # preferred format
-          config
-        elsif config_file_exists
-          raise "Invalid config file"
-        else
-          databases = {}
-
-          if !ENV["PGHERO_DATABASE_URL"] && spec_supported?
-            ActiveRecord::Base.configurations.configs_for(env_name: env, include_replicas_key => true).each do |db|
-              databases[db.send(spec_name_key)] = {"spec" => db.send(spec_name_key)}
-            end
+        @file_config =
+          if config[env]
+            config[env]
+          elsif config["databases"] # preferred format
+            config
+          elsif config_file_exists
+            raise "Invalid config file"
+          else
+            nil
           end
+      end
 
-          if databases.empty?
-            databases["primary"] = {
-              "url" => ENV["PGHERO_DATABASE_URL"] || connection_config(ActiveRecord::Base)
-            }
-          end
+      @file_config
+    end
 
-          if databases.size == 1
-            databases.values.first.merge!(
-              "db_instance_identifier" => ENV["PGHERO_DB_INSTANCE_IDENTIFIER"],
-              "gcp_database_id" => ENV["PGHERO_GCP_DATABASE_ID"],
-              "azure_resource_id" => ENV["PGHERO_AZURE_RESOURCE_ID"]
-            )
-          end
+    # private
+    def default_config
+      databases = {}
 
-          {
-            "databases" => databases
-          }
+      unless ENV["PGHERO_DATABASE_URL"]
+        ActiveRecord::Base.configurations.configs_for(env_name: env, include_replicas_key => true).each do |db|
+          databases[db.send(spec_name_key)] = {"spec" => db.send(spec_name_key)}
         end
       end
+
+      if databases.empty?
+        databases["primary"] = {
+          "url" => ENV["PGHERO_DATABASE_URL"] || connection_config(ActiveRecord::Base)
+        }
+      end
+
+      if databases.size == 1
+        databases.values.first.merge!(
+          "aws_db_instance_identifier" => ENV["PGHERO_DB_INSTANCE_IDENTIFIER"],
+          "gcp_database_id" => ENV["PGHERO_GCP_DATABASE_ID"],
+          "azure_resource_id" => ENV["PGHERO_AZURE_RESOURCE_ID"]
+        )
+      end
+
+      {
+        "databases" => databases
+      }
     end
 
     # ensure we only have one copy of databases
@@ -194,23 +224,18 @@ module PgHero
     # delete previous stats
     # go database by database to use an index
     # stats for old databases are not cleaned up since we can't use an index
-    def clean_query_stats
+    def clean_query_stats(before: nil)
       each_database do |database|
-        database.clean_query_stats
+        database.clean_query_stats(before: before)
       end
     end
 
-    def clean_space_stats
+    def clean_space_stats(before: nil)
       each_database do |database|
-        database.clean_space_stats
+        database.clean_space_stats(before: before)
       end
     end
 
-    # private
-    def spec_supported?
-      ActiveRecord::VERSION::MAJOR >= 6
-    end
-
     # private
     def connection_config(model)
       ActiveRecord::VERSION::STRING.to_f >= 6.1 ? model.connection_db_config.configuration_hash : model.connection_config

data/lib/tasks/pghero.rake

@@ -22,6 +22,16 @@ namespace :pghero do
   desc "Remove old query stats"
   task clean_query_stats: :environment do
     puts "Deleting old query stats..."
-    PgHero.clean_query_stats
+    options = {}
+    options[:before] = Float(ENV["KEEP_DAYS"]).days.ago if ENV["KEEP_DAYS"].present?
+    PgHero.clean_query_stats(**options)
+  end
+
+  desc "Remove old space stats"
+  task clean_space_stats: :environment do
+    puts "Deleting old space stats..."
+    options = {}
+    options[:before] = Float(ENV["KEEP_DAYS"]).days.ago if ENV["KEEP_DAYS"].present?
+    PgHero.clean_space_stats(**options)
   end
 end

data/licenses/LICENSE-chart.js.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2021 Chart.js Contributors
+Copyright (c) 2014-2022 Chart.js Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: