lexicon-cli 0.1.0

data/README.md

@@ -0,0 +1,5 @@
+# Lexicon::Cli
+
+This repository provides a CLI to download/upload/load/enable compiled lexicon packages into a Postgres (PostGIS) database.
+
+You can read the [documentation in the `doc/` folder](doc/usage.md)

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lexicon-cli"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/lexicon

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'lexicon-cli'
+
+require 'dotenv/load'
+
+application = Lexicon::Cli::Application.new(ARGV, extensions: [
+  Lexicon::Cli::Extension::CommonExtension.new(data_root: Pathname.new(__dir__).join('..')),
+  Lexicon::Cli::Extension::RemoteExtension.new,
+  Lexicon::Cli::Extension::ProductionExtension.new,
+])
+
+application.start

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lexicon-cli.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/lexicon/cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'lexicon-cli'
+  spec.version = Lexicon::Cli::VERSION
+  spec.authors = ['Ekylibre developers']
+  spec.email = ['dev@ekylibre.com']
+
+  spec.summary = 'Basic Cli for the Lexicon'
+  spec.required_ruby_version = '>= 2.6.0'
+  spec.homepage = 'https://www.ekylibre.com'
+  spec.license = 'AGPL-3.0-only'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.glob(%w[lib/**/*.rb bin/**/* *.gemspec Gemfile Rakefile *.md])
+
+  spec.bindir = 'bin'
+  spec.executables << 'lexicon'
+
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'corindon', '~> 0.7.0'
+  spec.add_dependency 'dotenv', '~> 2.7'
+  spec.add_dependency 'lexicon-common', '~> 0.1.0'
+  spec.add_dependency 'thor', '~> 1.0'
+  spec.add_dependency 'zeitwerk', '~> 2.4'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'minitest', '~> 5.14'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rubocop', '~> 1.3.1'
+end

data/lib/lexicon-cli.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'corindon'
+require 'lexicon-common'
+require 'thor'
+require 'zeitwerk'
+
+# Make sure the Lexicon module already exists so that Zeitwerk does not manage it
+module Lexicon
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore(__FILE__)
+loader.setup

data/lib/lexicon/cli/application.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lexicon
+  module Cli
+    class Application
+      attr_reader :args
+
+      def initialize(args, extensions: [])
+        @args = args
+        @extensions = extensions
+      end
+
+      def start
+        container = Corindon::DependencyInjection::Container.new
+        extensions.each do |extension|
+          extension.boot(container)
+        end
+
+        make_app(extensions).start(args, container: container)
+      end
+
+      private
+
+        # @return [Array<Lexicon::Cli::ExtensionBase>]
+        attr_reader :extensions
+
+        # @param [Array<Lexicon::Cli::ExtensionBase>]
+        # @return [Class]
+        def make_app(extensions)
+          Class.new(CliBase) do
+            extensions.each do |extension|
+              if (commands = extension.commands).is_a?(Proc)
+                instance_eval(&commands)
+              end
+            end
+          end
+        end
+    end
+  end
+end

data/lib/lexicon/cli/cli_base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lexicon
+  module Cli
+    class CliBase < Command::ContainerAwareCommand
+      def initialize(args = [], local_options = {}, config = {})
+        super(args, local_options, config)
+
+        register_config(container, options)
+      end
+
+      default_command :help
+      class_option :verbose, type: :boolean, default: false, aliases: ['v']
+      class_option :parallel, type: :boolean, default: false, aliases: ['P']
+
+      private
+
+        def register_config(container, options)
+          verbose = options['verbose']
+          parallel = options['parallel']
+          jobs = options.fetch('jobs', parallel ? 4 : 1)
+
+          container.set_parameter('config.verbose', verbose)
+          container.set_parameter('config.parallel', parallel)
+          container.set_parameter('config.jobs', jobs)
+        end
+    end
+  end
+end

data/lib/lexicon/cli/command/console_command.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Lexicon
+  module Cli
+    module Command
+      class ConsoleCommand < ContainerAwareCommand
+        default_command :exec_command
+
+        desc 'run console', ''
+
+        def exec_command
+          # rubocop:disable Lint/Debugger
+          binding.pry
+          # rubocop:enable Lint/Debugger
+        end
+
+        private
+
+          %i[collect load normalize].each do |meth|
+            define_method meth do |*names|
+              get('datasource.name_runner').run(names, action: meth)
+            end
+          end
+
+          def version_bump(part)
+            get('version.bumper').bump(part)
+          end
+
+          def release(*names)
+            get('database.dumper').dump(get('version'), datasource_names: names)
+          end
+
+          def load_package(version = nil)
+            version ||= get('version')
+
+            get('production.package.loader').load_package(version)
+          end
+      end
+    end
+  end
+end

data/lib/lexicon/cli/command/container_aware_command.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lexicon
+  module Cli
+    module Command
+      class ContainerAwareCommand < Thor
+        include Lexicon::Common::Mixin::ContainerAware
+
+        def initialize(args = [], local_options = {}, config = {})
+          super(args, local_options, config)
+
+          self.container = config[:container]
+        end
+      end
+    end
+  end
+end

data/lib/lexicon/cli/command/production_command.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Lexicon
+  module Cli
+    module Command
+      class ProductionCommand < ContainerAwareCommand
+        include Lexicon::Common::Mixin::SchemaNamer
+
+        desc 'loadable', 'List all available loadable versions'
+
+        def loadable
+          available_packages.each do |package|
+            puts package.version.to_s.green
+            package.file_sets
+                   .sort_by(&:name)
+                   .each do |fs|
+              puts ' -> ' + fs.name.send(fs.data_path.nil? ? :yellow : :green)
+            end
+          end
+        end
+
+        desc 'config', 'Display production config information'
+
+        def config
+          puts <<~TEXT
+            Version dir: #{container.parameter('lexicon.common.package_dir')}
+            Prod database URL: #{container.parameter('lexicon.common.production.database.url')}
+          TEXT
+        end
+
+        desc 'load <VERSION>', 'Load a package into the production database'
+        option :validate, type: :boolean, default: true
+        option :datasources, type: :array, default: []
+        option :without, type: :array, default: []
+
+        def load(pkg_name)
+          # @type [Production::DatasourceLoader] datasource_loader
+          datasource_loader = get(Lexicon::Common::Production::DatasourceLoader)
+          # @type [Package::PackageIntegrityValidator] integrity_validator
+          integrity_validator = get(Lexicon::Common::Package::PackageIntegrityValidator)
+          # @type [Package::DirectoryPackageLoader] package_loader
+          package_loader = get(Lexicon::Common::Package::DirectoryPackageLoader)
+
+          validate = options.fetch(:validate)
+          names = options.fetch(:datasources, [])
+          without = options.fetch(:without, [])
+          package = package_loader.load_package(pkg_name)
+
+          if package.nil?
+            puts '[ NOK ] Did not find any package to load'.red
+          elsif package.nil?
+            puts "[ NOK ] No Package found for version #{version}".red
+          elsif !validate || integrity_validator.valid?(package)
+            datasource_loader.load_package(package, only: (names.empty? ? nil : names), without: without)
+          else
+            puts "[ NOK ] Lexicon package #{package.version} is corrupted".red
+          end
+        end
+
+        desc 'versions', 'List versions available on the server'
+
+        def versions
+          puts "Lexicon is #{enabled? ? 'ENABLED'.green + " (#{enabled_version.to_s.yellow})" : 'DISABLED'.red}"
+
+          available = loaded_versions
+          if available.empty?
+            puts 'No other versions are loaded'
+          else
+            puts 'Available loaded versions are:'
+            loaded_versions
+              .each { |e| puts " - #{e}" }
+          end
+        end
+
+        desc 'disable', 'Disable the lexicon'
+
+        def disable
+          if enabled? && !(version = enabled_version).nil?
+            puts "Disabling version #{version.to_s.yellow}"
+            do_disable
+            puts '[  OK ] Done'.green
+          else
+            puts 'Lexicon is not enabled'.red
+          end
+        end
+
+        desc 'enable [version]', 'Enable the lexicon'
+
+        def enable(version = nil)
+          if enabled?
+            puts 'Disabling current version'
+            do_disable
+          end
+
+          semver = if version.nil?
+                     loaded_versions.max
+                   else
+                     Semantic::Version.new(version)
+                   end
+
+          puts "Enabling version #{semver.to_s.yellow}"
+
+          do_enable(semver)
+
+          puts '[  OK ] Done'.green
+        end
+
+        desc 'delete', 'Deletes a loaded version of the lexicon'
+
+        def delete(version)
+          semver = Semantic::Version.new(version)
+
+          if loaded_versions.include?(semver)
+            production_database
+              .query("DROP SCHEMA \"#{version_to_schema(semver)}\" CASCADE")
+
+            puts '[  OK ] '.green + "The version #{semver} has been deleted."
+          else
+            puts '[ NOK ] '.red + "The version #{semver.to_s.yellow} is not loaded or is enabled."
+          end
+        end
+
+        private
+
+          def production_database
+            get(Lexicon::Cli::Extension::ProductionExtension::DATABASE)
+          end
+
+          # @return [Array<Package::Package>]
+          def available_packages
+            # @type [Package::DirectoryPackageLoader] package_loader
+            package_loader = get(Lexicon::Common::Package::DirectoryPackageLoader)
+
+            if package_loader.root_dir.exist?
+              package_loader.root_dir
+                            .children
+                            .select(&:directory?)
+                            .map { |dir| package_loader.load_package(dir.basename.to_s) }
+                            .compact
+                            .sort { |a, b| a.version <=> b.version }
+            else
+              []
+            end
+          end
+
+          # @param [Semantic::Version] version
+          def do_enable(version)
+            production_database.query <<~SQL
+              BEGIN;
+                ALTER SCHEMA "lexicon__#{version.to_s.gsub('.', '_')}" RENAME TO "lexicon";
+                CREATE TABLE "lexicon"."version" ("version" VARCHAR);
+                INSERT INTO "lexicon"."version" VALUES ('#{version}');
+              COMMIT;
+            SQL
+          end
+
+          def do_disable
+            version = enabled_version
+            raise StandardError.new('No version table present, cannot continue automatically') if version.nil?
+
+            production_database.query <<~SQL
+              BEGIN;
+                DROP TABLE "lexicon"."version";
+                ALTER SCHEMA "lexicon" RENAME TO "#{version_to_schema(version)}";
+              COMMIT;
+            SQL
+          end
+
+          # @return [Array<Semantic::Version>]
+          def loaded_versions
+            disabled = production_database
+                         .query("SELECT nspname FROM pg_catalog.pg_namespace WHERE nspname LIKE 'lexicon__%';")
+                         .to_a
+                         .map { |name| schema_to_version(name.fetch('nspname')) }
+
+            enabled = enabled_version
+
+            if enabled.nil?
+              disabled
+            else
+              [*disabled, enabled].sort
+            end
+          end
+
+          # @return [Semantic::Version, nil]
+          def enabled_version
+            if version_table_present?
+              Semantic::Version.new(
+                production_database
+                  .query('SELECT version FROM lexicon.version LIMIT 1')
+                  .to_a.first
+                  .fetch('version')
+              )
+            else
+              nil
+            end
+          end
+
+          # @param [String, nil] version
+          # @return [Semantic::Version]
+          def as_version(version, &block)
+            if version.nil?
+              block.call
+            else
+              Semantic::Version.new(version)
+            end
+          end
+
+          def version_table_present?
+            production_database
+              .query("SELECT count(*) AS presence FROM information_schema.tables WHERE table_schema = 'lexicon' AND table_name = 'version'")
+              .to_a.first
+              .fetch('presence').to_i.positive?
+          end
+
+          def enabled?
+            production_database
+              .query("SELECT count(nspname) AS presence FROM pg_catalog.pg_namespace WHERE nspname = 'lexicon'")
+              .to_a.first
+              .fetch('presence').to_i.positive?
+          end
+      end
+    end
+  end
+end