gleis 0.1.0

data/lib/gleis/database.rb

@@ -0,0 +1,126 @@
+module Gleis
+  # The class implements the methods required for the databases of a gleis app
+  class Database
+    def self.backup(app_name)
+      token = Token.check
+      Utils.check_for_local_pg_command('pg_dump')
+      url = Config.get_env_var(app_name, token, 'DATABASE_URL')
+      abort('There is no database configured under the DATABASE_URL variable.') unless url
+      db_name = url.split('/').last
+      timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+      backup_file = "/tmp/#{app_name}_#{db_name}_#{timestamp}.pgdump"
+      if system("pg_dump -f #{backup_file} #{url}")
+        puts "Database configured at DATABASE_URL succesfully backed up locally in #{backup_file}"
+      else
+        puts 'Failed to backup database configured under DATABASE_URL'
+      end
+    end
+
+    def self.delete(app_name, env_var_name)
+      token = Token.check
+      if Utils.prompt_confirmation("Are you sure you want to delete the database at #{env_var_name}?")
+        body = API.request('delete', "db/#{app_name}/#{env_var_name}", token)
+        if body['success'] == 1
+          puts "Successfully deleted database configured at #{env_var_name}."
+        else
+          puts "Failed to delete database: #{body['message']}"
+        end
+      else
+        puts 'Command cancelled'
+      end
+    end
+
+    def self.info(app_name)
+      token = Token.check
+      url = Config.get_env_var(app_name, token, 'DATABASE_URL')
+      abort_message = 'You do not have a database or you did not promote it yet. '\
+        'You can create one with the db:new command and promote it with db:promote.'
+      abort(abort_message) unless url
+      # Get database info
+      db_name = url.split('/').last
+      body = API.request('get', "database/#{db_name}", token)
+      return unless body['success'] == 1
+
+      db = body['database']
+      puts "Info about database at DATABASE_URL:\n\n"
+      puts "\tName:\t\t#{db['name']}\n" \
+        "\tCreated on:\t#{Time.parse(db['created_at']).strftime('%c')}"
+      if body['available']
+        puts "\tStatus:\t\tavailable\n" \
+          "\tDatabase:\t#{body['version']}\n" \
+          "\tConnections:\t#{body['connections']}"
+      else
+        puts "\tStatus:\t\tnot available"
+      end
+    end
+
+    def self.new(app_name)
+      token = Token.check
+      body = API.request('post', 'db', token, 'name': app_name)
+      if body['success'] == 1
+        puts "Successfully created new database for #{app_name} available as config variable #{body['message']}"
+      else
+        puts 'Failed to create new database'
+      end
+    end
+
+    def self.promote(app_name, env_var_name)
+      token = Token.check
+      body = API.request('post', 'db/promote', token, 'name': app_name, 'var': env_var_name)
+      if body['success'] == 1
+        puts "Succesfully promoted database environment variable #{env_var_name} to DATABASE_URL"
+      else
+        puts 'Failed to promote database environment variable'
+      end
+    end
+
+    def self.push(app_name, local_name)
+      token = Token.check
+      Utils.check_for_local_pg_command('pg_dump')
+      Utils.check_for_local_pg_command('pg_restore')
+      url = Config.get_env_var(app_name, token, 'DATABASE_URL')
+      abort('There is no database configured under the DATABASE_URL variable.') unless url
+      ENV['PGCONNECT_TIMEOUT'] = '5'
+      # Check if database is empty
+      sql_statement = "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema='public'"
+      table_count = `psql #{url} -t -A -c "#{sql_statement}"`.chomp
+      if table_count.to_i.zero?
+        # Check connection to local database
+        unless system("psql -c 'SELECT 1' #{local_name} >/dev/null 2>&1")
+          abort("Failed to connect to local database #{local_name}, please check " \
+            'that the database name is correct and that you have access to it.')
+        end
+        if system("pg_dump -Fc -x #{local_name} | pg_restore -O -n public -d #{url}")
+          puts "Successfully pushed local database #{local_name} to database configured at DATABASE_URL."
+        else
+          puts "Failed to push local database #{local_name} to DATABASE_URL."
+        end
+      else
+        puts 'The database configured at DATABASE_URL already contains data, please empty it first.'
+      end
+    end
+
+    def self.psql(app_name)
+      token = Token.check
+      abort('The PostgreSQL client psql is not installed on this system.') unless system('which psql >/dev/null')
+      url = Config.get_env_var(app_name, token, 'DATABASE_URL')
+      abort('There is no database configured under the DATABASE_URL variable.') unless url
+      ENV['PGCONNECT_TIMEOUT'] = '5'
+      exec("psql #{url}")
+    end
+
+    def self.reset(app_name, env_var_name)
+      token = Token.check
+      if Utils.prompt_confirmation("Are you sure you want to reset the database at #{env_var_name}?")
+        body = API.request('put', 'db', token, 'name': app_name, 'var': env_var_name)
+        if body['success'] == 1
+          puts "Successfully reset database configured at #{env_var_name}."
+        else
+          puts "Failed to delete database: #{body['message']}"
+        end
+      else
+        puts 'Command cancelled'
+      end
+    end
+  end
+end

data/lib/gleis/domain.rb

@@ -0,0 +1,39 @@
+module Gleis
+  # The class implements the methods required to manage the domain names of a gleis app
+  class Domain
+    def self.add(app_name, name)
+      token = Token.check
+      body = API.request('post', 'domains', token, 'name': app_name, 'domain': name)
+      if body['success'] == 1
+        puts "Successfully added domain to #{app_name}."
+      else
+        puts "Failed to add domain: #{body['message']}"
+      end
+    end
+
+    def self.list(app_name)
+      token = Token.check
+      body = API.request('get', "domains/#{app_name}", token)
+      puts "Your app is available under the URL: https://#{body['fqdn']}\n\n"
+      domains = body ['data']
+      if domains.any?
+        puts "Domain list for #{app_name}:\n\n"
+        domains.each do |domain|
+          puts "\t#{domain['name']}"
+        end
+      else
+        puts 'No domains defined yet.'
+      end
+    end
+
+    def self.remove(app_name, name)
+      token = Token.check
+      body = API.request('delete', "domains/#{app_name}/#{name}", token)
+      if body['success'] == 1
+        puts "Successfully removed domain name from #{app_name}."
+      else
+        puts "Failed to remove domain name: #{body['message']}"
+      end
+    end
+  end
+end

data/lib/gleis/main.rb

@@ -0,0 +1,36 @@
+require 'thor'
+require 'gleis'
+
+module Gleis
+  # This class defines all the main command-line interface commands for gleis
+  class Main < Thor
+    desc 'login USERNAME', 'Login into Gleis'
+    def login(username)
+      Authentication.login(username)
+    end
+
+    desc 'addon COMMAND', 'Manage add-ons: add, list, remove'
+    subcommand 'addon', CLI::Addon
+
+    desc 'app COMMAND', 'Manage applications: create, start, stop, logs, etc.'
+    subcommand 'app', CLI::App
+
+    desc 'auth COMMAND', 'Authentication commands: login, logout, whoami'
+    subcommand 'auth', CLI::Auth
+
+    desc 'db COMMAND', 'Manage databases: info, new, promote, psql, etc.'
+    subcommand 'db', CLI::Db
+
+    desc 'domain COMMAND', 'Manage domains: add, list, remove'
+    subcommand 'domain', CLI::Domain
+
+    desc 'mgmt COMMAND', 'Administration and management related commands'
+    subcommand 'mgmt', CLI::Management
+
+    desc 'sharing COMMAND', 'Manage collaboration: add, list, remove'
+    subcommand 'sharing', CLI::Sharing
+
+    desc 'storage COMMAND', 'Manage persistent storage: add, list, sync, etc.'
+    subcommand 'storage', CLI::Storage
+  end
+end

data/lib/gleis/management.rb

@@ -0,0 +1,42 @@
+module Gleis
+  # The class implements management and administrative methods around the Gleis platform
+  class Management
+    def self.apps
+      token = Token.check
+      body = API.request('get', 'mgmt/apps', token)
+      apps = body ['data']
+      if apps.any?
+        puts "Apps list for your organisation:\n\n"
+        printf("\t%-39s %-25s %s\n", 'APP NAME', 'CREATED ON', 'PLAN')
+        printf("\t%-39s %-25s %s\n\n", '--------', '----------', '----')
+        apps.each do |app|
+          printf("\t%-39s %-25s %s\n", app['name'], Time.parse(app['created_at']).localtime.strftime('%c'),
+                 app['plan_name'].capitalize)
+        end
+      else
+        puts 'No apps found.'
+      end
+    end
+
+    def self.license
+      puts <<LICENSE
+      Gleis Command Line Interface for the Gleis Platform as a Service
+      Copyright (C) 2018 towards GmbH
+
+      This program is free software: you can redistribute it and/or modify
+      it under the terms of the GNU General Public License as published by
+      the Free Software Foundation, either version 3 of the License, or
+      (at your option) any later version.
+
+      This program is distributed in the hope that it will be useful,
+      but WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+      GNU General Public License for more details.
+
+      You should have received a copy of the GNU General Public License
+      along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+LICENSE
+    end
+  end
+end

data/lib/gleis/params.rb

@@ -0,0 +1,9 @@
+module Gleis
+  # This class deals with the CLI config parameters stored on the API server
+  class Params
+    def self.get_cli_parameters(token)
+      body = API.request('get', 'params', token)
+      body['data']
+    end
+  end
+end

data/lib/gleis/sharing.rb

@@ -0,0 +1,38 @@
+module Gleis
+  # The class implements the methods required for collaborating on a gleis app
+  class Sharing
+    def self.add(app_name, email, role)
+      token = Token.check
+      body = API.request('post', 'sharing', token, 'name': app_name, 'email': email, 'role': role)
+      if body['success'] == 1
+        puts "Successfully added user to access list for #{app_name}."
+      else
+        puts "Failed to add user to access list: #{body['message']}"
+      end
+    end
+
+    def self.list(app_name)
+      token = Token.check
+      body = API.request('get', "sharing/#{app_name}", token)
+      acls = body ['acl']
+      if acls.any?
+        puts "Access list for #{app_name}:\n\n"
+        acls.each do |acl|
+          printf("\t%-45s %s\n", acl['user_name'], acl['role_name'])
+        end
+      else
+        puts 'No access list defined yet.'
+      end
+    end
+
+    def self.remove(app_name, email)
+      token = Token.check
+      body = API.request('delete', "sharing/#{app_name}/#{email}", token)
+      if body['success'] == 1
+        puts "Successfully removed user from access list for #{app_name}."
+      else
+        puts "Failed to remove user from access list: #{body['message']}"
+      end
+    end
+  end
+end

data/lib/gleis/ssh.rb

@@ -0,0 +1,36 @@
+require 'socket'
+
+module Gleis
+  # This class manages the SSH config and keys on the client side
+  class SSH
+    def self.generate_key(key_file, username)
+      return if File.exist?(key_file)
+
+      puts 'Could not find an existing public/private key pair'
+      return unless Utils.prompt_yes_no('Would you like to generate one now?')
+
+      hostname = Socket.gethostname
+      datetime = Time.now.strftime('%Y-%m-%d %H:%M')
+      # returns true on success
+      system('ssh-keygen', '-f', key_file, '-b 4096',
+             "-C generated by Gleis CLI for #{username} by #{ENV['USER']}@#{hostname} on #{datetime}")
+    end
+
+    def self.load_public_key(key_file)
+      public_key_file = key_file + '.pub'
+      return File.read(public_key_file).chomp if File.exist?(public_key_file)
+    end
+
+    def self.add_host_to_config(git_host, run_host, key_file)
+      config_file = Dir.home + '/.ssh/config'
+      ssh_host_line = "Host #{git_host} #{run_host}"
+      # Check if SSH config for hosts already exists
+      return if Utils.line_exists_in_file(key_file, ssh_host_line)
+
+      f = File.open(config_file, 'a')
+      f.puts ssh_host_line
+      f.puts "\tIdentityFile #{key_file}"
+      f.close
+    end
+  end
+end

data/lib/gleis/storage.rb

@@ -0,0 +1,69 @@
+module Gleis
+  # The class implements the methods required to the storage of a gleis app
+  class Storage
+    def self.add(app_name, type)
+      token = Token.check
+      body = API.request('post', 'storage', token, 'name': app_name, 'type': type)
+      if body['success'] == 1
+        puts "Successfully added #{type} storage to #{app_name}. As soon as you restart " \
+          "your app the storage will be available under the #{body['mount_target']} directory."
+      else
+        puts "Failed to add storage: #{body['message']}"
+      end
+    end
+
+    def self.attach(app_name, dir)
+      token = Token.check
+      body = API.request('post', 'storage/attach', token, 'name': app_name, 'dir': dir)
+      if body['success'] == 1
+        puts "Successfully attached storage to #{dir} directory. As soon as you restart your app " \
+          'the storage will be available under this directory.'
+      else
+        puts "Failed to attach storage: #{body['message']}"
+      end
+    end
+
+    def self.list(app_name)
+      token = Token.check
+      action = 'storage/' + app_name
+      body = API.request('get', action, token)
+      puts "Available storage types:\n\n"
+      printf("\t%-8s %s\n", 'TYPE', 'DESCRIPTION')
+      printf("\t%-8s %s\n\n", '----', '-----------')
+      body['data']['storage_types'].each do |st|
+        printf("\t%-8s %s\n", st['name'], st['description'])
+      end
+      if body['data']['storage'].any?
+        puts "\nStorage in use by app:\n\n"
+        printf("\t%-8s %-30s %-25s %s\n", 'TYPE', 'MOUNT TARGET', 'CREATED ON', 'USAGE')
+        printf("\t%-8s %-30s %-25s %s\n\n", '----', '------------', '-----------', '-----')
+        body['data']['storage'].each do |s|
+          printf("\t%-8s %-30s %-25s %s\n", s['storage_type_name'], s['mount_target'],
+                 Time.parse(s['created_at']).localtime.strftime('%c'), s['usage'])
+        end
+      else
+        puts "\nYour app is not currently using any storage."
+      end
+    end
+
+    def self.sync(app_name, dir)
+      token = Token.check
+      abort("Directory #{dir} does not exist or is not a directory.") unless Dir.exist?(dir)
+      # Get CLI parameters from API server
+      params = Params.get_cli_parameters(token)
+      abort('The rsync tool is not installed on this system.') unless system('which rsync >/dev/null')
+      body = API.request('get', "storage/#{app_name}", token)
+      if body['success'] == 1
+        if body['storage']
+          ns_app_name = "#{body['namespace']}_#{app_name}"
+          ENV['RSYNC_PASSWORD'] = body['storage']['password']
+          exec("rsync -rth --progress #{dir}/ rsync://#{ns_app_name}@#{params['sync_server']}/#{ns_app_name}")
+        else
+          puts 'No storage configured yet.'
+        end
+      else
+        puts 'Failed to get storage info.'
+      end
+    end
+  end
+end

data/lib/gleis/token.rb

@@ -0,0 +1,21 @@
+module Gleis
+  # This class manages the authentication token granted from the API server
+  class Token
+    def self.save(token)
+      abort('No tokens received.') unless token
+      f = File.new(Config::TOKEN_FILE, 'w', 0o0640)
+      f.write(token)
+      f.close
+    end
+
+    def self.check
+      return File.read(Config::TOKEN_FILE) if File.exist?(Config::TOKEN_FILE)
+
+      abort('Not authenticated, please login first.')
+    end
+
+    def self.delete
+      File.delete(Config::TOKEN_FILE) if File.exist?(Config::TOKEN_FILE)
+    end
+  end
+end

data/lib/gleis/utils.rb

@@ -0,0 +1,105 @@
+module Gleis
+  # This class gathers various utilities as small methods
+  class Utils
+    def self.convert_username_to_filename(username)
+      username.sub('@', '_at_').tr('.', '_')
+    end
+
+    def self.prompt_password
+      print 'Password: '
+      system 'stty -echo'
+      password = $stdin.gets.chomp
+      system 'stty echo'
+      puts
+      password
+    end
+
+    def self.prompt_yes_no(text)
+      loop do
+        print text + ' [y/n]: '
+        case STDIN.gets.strip
+        when 'Y', 'y', 'yes'
+          return true
+        when /\A[nN]o?\Z/
+          return false
+        end
+      end
+    end
+
+    def self.app_name
+      Dir.pwd.split('/').last
+    end
+
+    def self.check_for_local_pg_command(command)
+      abort("The PostgreSQL client required to run the command #{command}) is not installed on this system.") unless
+        system("which #{command} >/dev/null")
+    end
+
+    def self.validate_scale_count(count)
+      count_i = count.to_i
+      abort('Please specifiy a number between 1 and 10 as parameter in order to scale your app.') unless
+        count_i&.between?(1, 10)
+      count_i
+    end
+
+    def self.add_remote_to_git_config(remote_url)
+      config_file = Dir.pwd + '/.git/config'
+      return false unless File.exist?(config_file)
+
+      # Check if gleis remote already exists
+      git_remote_line = '[remote "gleis"]'
+      return if line_exists_in_file(config_file, git_remote_line)
+
+      f = File.open(config_file, 'a')
+      f.puts "\n#{git_remote_line}"
+      f.puts "\turl = #{remote_url}"
+      f.puts "\tfetch = +refs/heads/*:refs/remotes/origin/*"
+      f.close
+    end
+
+    def self.line_exists_in_file(file, line)
+      File.readlines(file).grep(/#{Regexp.escape(line)}/).size.positive?
+    end
+
+    def self.prompt_confirmation(text)
+      print 'WARNING: ' + text + ' (write YES in uppercase to confirm): '
+      answer = STDIN.gets.chomp
+      answer == 'YES'
+    end
+
+    def self.output_tasks(tasks, type)
+      tasks.each do |task|
+        timestamp_formatted = Time.parse(task['timestamp']).localtime.strftime('%c')
+        puts "#{type}.#{task['slot']}: #{task['status']} #{timestamp_formatted}"
+      end
+    end
+
+    def self.output_config_env_vars(env_vars, app_name)
+      puts "Configuration (environment variables) for #{app_name}:\n\n"
+      env_vars.each do |key, value|
+        puts "\t#{key}=#{value}"
+      end
+    end
+
+    def self.generate_docker_cmd_env_vars(env_vars)
+      env_vars_param = ''
+      env_vars.each do |key, value|
+        env_vars_param << " -e #{key}=#{value}"
+      end
+      env_vars_param
+    end
+
+    def self.generate_docker_cmd_mount(body, app_name)
+      mount_param = ''
+      if body['success'] == 1
+        storage_type = body['storage_type']
+        if storage_type
+          storage = body['storage']
+          mount_src = "#{storage_type['mount_source']}/#{body['namespace']}/#{app_name}"
+          mount_param = "--mount type=#{storage_type['mount_type']},src=#{mount_src},dst=#{storage['mount_target']}"
+        end
+      end
+      mount_param
+    end
+  end
+end

data/lib/gleis/version.rb

@@ -0,0 +1,3 @@
+module Gleis
+  VERSION = '0.1.0'
+end

data/lib/gleis.rb

@@ -0,0 +1,29 @@
+require 'gleis/utils'
+require 'gleis/authentication'
+require 'gleis/addon'
+require 'gleis/api'
+require 'gleis/application'
+require 'gleis/cli/addon'
+require 'gleis/cli/app'
+require 'gleis/cli/auth'
+require 'gleis/cli/db'
+require 'gleis/cli/domain'
+require 'gleis/cli/management'
+require 'gleis/cli/sharing'
+require 'gleis/cli/storage'
+require 'gleis/config'
+require 'gleis/database'
+require 'gleis/domain'
+require 'gleis/management'
+require 'gleis/params'
+require 'gleis/sharing'
+require 'gleis/ssh'
+require 'gleis/storage'
+require 'gleis/token'
+require 'gleis/version'
+
+require 'json'
+
+# Top-level gleis module namespace
+module Gleis
+end