gleis 0.1.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'gleis'
+
+# 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/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/exe/gleis

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'gleis/main'
+
+puts "\n###  Gleis CLI Copyright (c) 2018 towards GmbH - v#{Gleis::VERSION} - https://gleis.cloud  ###\n\n"
+
+Gleis::Main.start

data/lib/gleis/addon.rb

@@ -0,0 +1,41 @@
+module Gleis
+  # The class implements the methods required to manage the add-ons of a gleis app
+  class Addon
+    def self.add(app_name, name)
+      token = Token.check
+      body = API.request('post', 'addons', token, 'name': app_name, 'addon': name)
+      if body['success'] == 1
+        puts "Successfully added #{name} add-on to #{app_name}."
+      else
+        puts "Failed to add add-on: #{body['message']}"
+      end
+    end
+
+    def self.list(app_name)
+      token = Token.check
+      body = API.request('get', "addons/#{app_name}", token)
+      addons = body ['data']
+      if addons.any?
+        puts "List of available add-ons:\n\n"
+        printf("\t%-30s %-15s %s\n", 'ADD-ON NAME', 'VERSION', 'CATEGORY')
+        printf("\t%s\n\n", 'DESCRIPTION')
+        addons.each do |addon|
+          printf("\t%-30s %-15s %s\n", addon['name'], addon['version'], addon['category'])
+          puts "\t#{addon['description']}\n"
+        end
+      else
+        puts 'No add-ons avaialble.'
+      end
+    end
+
+    def self.remove(app_name, name)
+      token = Token.check
+      body = API.request('delete', "addons/#{app_name}/#{name}", token)
+      if body['success'] == 1
+        puts "Successfully removed #{name} add-on from #{app_name}."
+      else
+        puts "Failed to remove add-on: #{body['message']}"
+      end
+    end
+  end
+end

data/lib/gleis/api.rb

@@ -0,0 +1,45 @@
+require 'rest-client'
+
+module Gleis
+  # This class uses REST over HTTPS to communicate with the API server
+  class API
+    def self.request(method, action, token = nil, body = {})
+      url = Config::API_URL + Config::API_VERSION + '/cli/' + action
+      # Support legacy rest-client (<2.0) which does not have RestClient::NotFound
+      notfound_exception = defined?(RestClient::ResourceNotFound) ? RestClient::ResourceNotFound : RestClient::NotFound
+      begin
+        case method
+        when 'get', 'delete'
+          resp = RestClient.send(method, url, 'X-Gleis-Token': token, content_type: :json, accept: :json)
+        when 'post', 'put'
+          if token
+            resp =
+              RestClient.send(method, url, body.to_json, 'X-Gleis-Token': token, content_type: :json, accept: :json)
+          else
+            resp = RestClient.send(method, url, body.to_json, content_type: :json, accept: :json)
+          end
+        end
+      rescue RestClient::BadRequest
+        abort('Authentication failed.')
+      rescue RestClient::Unauthorized
+        abort('Not authenticated, please login first.')
+      rescue RestClient::Forbidden
+        abort('You do not have the required permissions, please contact the app owner.')
+      rescue notfound_exception
+        abort('Application not found.')
+      rescue RestClient::InternalServerError
+        abort('An error occured on the platform. Please contact support if this problem persists.')
+      rescue StandardError # (e.g. SocketError, Errno::ECONNREFUSED, RestClient::BadGateway, ...)
+        abort('There was an issue connecting to the Gleis API server.')
+      else
+        if resp.body.empty?
+          # If there is no body return whole response object
+          resp
+        else
+          # Return Ruby data structure of the JSON parsed body
+          JSON.parse(resp.body)
+        end
+      end
+    end
+  end
+end

data/lib/gleis/application.rb

@@ -0,0 +1,198 @@
+module Gleis
+  # The class implements the methods required to manage gleis applications
+  class Application
+    def self.config(app_name, env_var)
+      token = Token.check
+      if env_var.end_with? '='
+        # Delete variable
+        var_name = env_var.split('=')[0]
+        response = API.request('delete', "config/#{app_name}/#{var_name}", token)
+        puts "Deleted environment variable #{var_name}" if response.code == 204
+      elsif env_var.include? '='
+        # Update or create variable
+        var_value = env_var.split('=')
+        response = API.request('post', 'config', token, 'name': app_name, 'var': var_value[0], 'value': var_value[1])
+        puts "Sucessfully created environment variable #{var_value[0]}" if response.code == 201
+        puts "Sucessfully updated environment variable #{var_value[0]}" if response.code == 200
+      else
+        config_body = Config.get_env_vars(app_name, token)
+        Utils.output_config_env_vars(config_body['env_vars'], app_name)
+      end
+    end
+
+    def self.create(app_name)
+      token = Token.check
+      print "Creating new app named #{app_name}, you should be ready to go in about 10 seconds ... "
+      body = API.request('post', 'create', token, 'name': app_name)
+      # Check status of project creation in Gitlab
+      if body['success'] == 1
+        puts "done!\n"
+        git_ssh_url_to_repo = body['ssh_url_to_repo']
+        # Add git remote if .git/config file is detected
+        if Utils.add_remote_to_git_config(git_ssh_url_to_repo) == false
+          puts "Now add the gleis git remote to your app using: git remote add gleis #{git_ssh_url_to_repo}"
+        else
+          puts 'Git remote gleis added to your git config'
+        end
+        puts 'When ready to deploy your app, push it to the gleis git remote with: git push gleis master'
+        puts "You can then access your app using the URL https://#{body['dns_name']}" if body.key? 'dns_name'
+      else
+        puts 'failed!'
+      end
+    end
+
+    def self.deployments(app_name)
+      token = Token.check
+      action = 'deployment/' + app_name
+      body = API.request('get', action, token)
+      if body['deployments'].any?
+        body['deployments'].reverse_each do |d|
+          puts "v#{d['version']} | #{d['commit'][0, 7]} | #{d['email']} | #{d['subject']}\n" \
+            "deployed by #{d['name']} on #{Time.parse(d['created_at']).strftime('%c')}\n\n"
+        end
+      else
+        puts 'No deployments found, please deploy your app first.'
+      end
+    end
+
+    def self.destroy(app_name)
+      token = Token.check
+      if Utils.prompt_confirmation("Are you sure you want to destroy the #{app_name} app?")
+        # Delete everything related to project/app
+        body = API.request('post', 'delete', token, 'name': app_name)
+        if body['success'] == 1
+          puts 'App destroyed successfully'
+        else
+          puts 'Failed to destroy app: ' + body['message']
+        end
+      else
+        puts 'Command cancelled'
+      end
+    end
+
+    def self.exec(app_name, command)
+      token = Token.check
+      config_body = Config.get_env_vars(app_name, token)
+      # Get storage and generate Docker mount parameter
+      mount_param = Utils.generate_docker_cmd_mount(API.request('get', "storage/#{app_name}", token), app_name)
+      # Get deployments and commit from last deployment
+      dp_body = API.request('get', "deployment/#{app_name}", token)
+      if dp_body['deployments'].any?
+        # Get CLI parameters from API server
+        p = Params.get_cli_parameters(token)
+        system("ssh -t -q -o 'StrictHostKeyChecking=no' \
+          -p #{p['run_port']} \
+          #{p['run_username']}@#{p['run_server']} \
+          '#{Utils.generate_docker_cmd_env_vars(config_body['env_vars'])} #{mount_param} \
+            #{p['registry_server']}/#{dp_body['namespace']}/#{app_name}:#{dp_body['deployments'].last['commit'][0..6]} \
+            #{command}'")
+      else
+        puts 'No deployments found, please deploy your app first.'
+      end
+    end
+
+    def self.git(app_name)
+      token = Token.check
+      action = 'git/' + app_name
+      body = API.request('get', action, token)
+      if body['success'] == 1
+        puts "The URL to the git repo of the #{app_name} app is: #{body['data']}"
+      else
+        puts 'Failed to fetch git URL for app.'
+      end
+    end
+
+    def self.logs(app_name)
+      token = Token.check
+      action = 'logs/' + app_name
+      body = API.request('get', action, token)
+      if body['log'].nil? || body['log'].empty?
+        puts 'No log entries found yet.'
+      else
+        puts "Last 100 lines of consolidated log output for #{app_name}:"
+        puts
+        puts body['log']
+      end
+    end
+
+    def self.restart(app_name)
+      token = Token.check
+      body = API.request('post', 'restart', token, 'name': app_name)
+      if body['success'] == 1
+        puts 'Successfully restarted app using rolling update'
+      else
+        puts 'Failed to restart app: ' + body['error_text']
+      end
+    end
+
+    def self.scale(app_name, replica)
+      token = Token.check
+      count = Utils.validate_scale_count(replica)
+      body = API.request('post', 'scale', token, 'name': app_name, 'count': count)
+      if body['success'] == 1
+        puts "Successfully scaled app to #{count} replica"
+        if body['message']
+          puts 'Note that your app is currently not running, hence scaling will take effect as soon as you start it'
+        end
+      else
+        puts "Failed to scale app: #{body['message']}"
+      end
+    end
+
+    def self.start(app_name)
+      token = Token.check
+      body = API.request('post', 'start', token, 'name': app_name)
+      if body['success'] == 1
+        puts 'Successfully started app'
+      else
+        puts 'Failed to start app: ' + body['message']
+      end
+    end
+
+    def self.ps(app_name)
+      token = Token.check
+      body = API.request('get', "ps/#{app_name}", token)
+      puts 'Failed to get processes.' unless body['success'] == 1
+      if body['data']&.size&.positive?
+        body['data'].each_with_index do |service, index|
+          puts "=== #{service[0]}: `#{service[1]['command']}`"
+          if service[1]['tasks'].empty?
+            puts 'No processes running'
+          else
+            Utils.output_tasks(service[1]['tasks'], service[1]['type'])
+          end
+          puts '' if index != body['data'].size - 1
+        end
+      else
+        puts 'No deployments found, please deploy your app first.'
+      end
+    end
+
+    def self.status(app_name)
+      token = Token.check
+      action = 'status/' + app_name
+      body = API.request('get', action, token)
+      puts "Status of app #{app_name}:\n\n"
+      if body['success'] == 1
+        status = body['status']
+        puts "\tStatus:\t\trunning\n" \
+             "\tStarted at:\t#{Time.parse(status['createdat']).localtime.strftime('%c')}\n" \
+             "\tUpdated at:\t#{Time.parse(status['updatedat']).localtime.strftime('%c')}\n" \
+             "\tUpdate count:\t#{status['forceupdate']}\n" \
+             "\tReplicas:\t#{status['replicas']}"
+      else
+        puts "\tStatus:\t\tnot running"
+      end
+    end
+
+    def self.stop(app_name)
+      token = Token.check
+      body = API.request('post', 'stop', token, 'name': app_name)
+      if body['success'] == 1
+        puts 'Succesfully stopped app'
+      else
+        puts 'Failed to stop app: ' + body['message']
+      end
+    end
+  end
+end

data/lib/gleis/authentication.rb

@@ -0,0 +1,47 @@
+module Gleis
+  # This class implements all authentication related commands of the CLI
+  class Authentication
+    def self.login(username)
+      puts 'Login to Gleis'
+      username = username.downcase
+      password = Utils.prompt_password
+
+      body = API.request('post', 'login', nil, 'username': username, 'password': password)
+      token = body['token']
+
+      Token.save(token)
+      puts 'Authentication successful'
+      puts "\nNEWS: #{body['data']}\n\n" unless body['data'].nil?
+      # Generate SSH key pair if not found and upload pub key
+      ssh_key_filename = Config::SSH_KEY_FILE_BASE + '_' + Utils.convert_username_to_filename(username)
+      upload_ssh_public_key(ssh_key_filename, token) if SSH.generate_key(ssh_key_filename, username)
+    end
+
+    def self.whoami
+      token = Token.check
+      body = API.request('get', 'whoami', token)
+      puts "You are currently logged in as #{body['data']}"
+    end
+
+    def self.logout
+      token = Token.check
+      puts 'Logout of Gleis'
+      API.request('post', 'logout', token, {})
+      Token.delete
+      puts 'Logout successful'
+    end
+
+    def self.upload_ssh_public_key(filename, token)
+      ssh_public_key = SSH.load_public_key(filename)
+      body = API.request('post', 'upload_ssh_pub_key', token, 'ssh_public_key' => ssh_public_key)
+      if body['success'] == 1
+        puts "Successfully uploaded your SSH public key #{filename}.pub"
+        # Get run server name
+        params = Params.get_cli_parameters(token)
+        SSH.add_host_to_config(body['git_server'], params['run_server'], filename)
+      else
+        puts "Failed to upload SSH public key: #{body['message']}"
+      end
+    end
+  end
+end

data/lib/gleis/cli/addon.rb

@@ -0,0 +1,23 @@
+module Gleis
+  module CLI
+    # Add-ons-related CLI commands
+    class Addon < Thor
+      class_option :app, aliases: :a, type: :string, default: Utils.app_name
+
+      desc 'add ADDON', 'Add add-on to app'
+      def add(name)
+        Gleis::Addon.add(options[:app], name)
+      end
+
+      desc 'list', 'List available add-ons on Gleis and add-ons used by app'
+      def list
+        Gleis::Addon.list(options[:app])
+      end
+
+      desc 'remove ADDON', 'Add add-on to app'
+      def remove(name)
+        Gleis::Addon.remove(options[:app], name)
+      end
+    end
+  end
+end

data/lib/gleis/cli/app.rb

@@ -0,0 +1,73 @@
+module Gleis
+  module CLI
+    # Application-related CLI commands
+    class App < Thor
+      class_option :app, aliases: :a, type: :string, default: Utils.app_name
+
+      desc 'config [VAR=value]', 'Show, set or delete environment variables'
+      def config(env_var = '')
+        Application.config(options[:app], env_var)
+      end
+
+      desc 'create', 'Create new application'
+      def create
+        Application.create(options[:app])
+      end
+
+      desc 'destroy', 'Destroy application'
+      def destroy
+        Application.destroy(options[:app])
+      end
+
+      desc 'deployments', 'List all deployments'
+      def deployments
+        Application.deployments(options[:app])
+      end
+
+      desc 'exec COMMAND', 'Execute a one-time-command (e.g. rails db:migrate)'
+      def exec(command)
+        Application.exec(options[:app], command)
+      end
+
+      desc 'git', 'Show URL of git repository'
+      def git
+        Application.git(options[:app])
+      end
+
+      desc 'logs', 'View last log entries'
+      def logs
+        Application.logs(options[:app])
+      end
+
+      desc 'ps', 'Show running processes'
+      def ps
+        Application.ps(options[:app])
+      end
+
+      desc 'restart', 'Restart application (rolling update)'
+      def restart
+        Application.restart(options[:app])
+      end
+
+      desc 'scale #REPLICA', 'Scale up or down (horizontal scaling)'
+      def scale(replica)
+        Application.scale(options[:app], replica)
+      end
+
+      desc 'start', 'Start application'
+      def start
+        Application.start(options[:app])
+      end
+
+      desc 'status', 'Status of application'
+      def status
+        Application.status(options[:app])
+      end
+
+      desc 'stop', 'Stop application'
+      def stop
+        Application.stop(options[:app])
+      end
+    end
+  end
+end

data/lib/gleis/cli/auth.rb

@@ -0,0 +1,21 @@
+module Gleis
+  module CLI
+    # Authentication-related CLI commands
+    class Auth < Thor
+      desc 'login USERNAME', 'Login into Gleis'
+      def login(username)
+        Authentication.login(username)
+      end
+
+      desc 'logout', 'Logout of Gleis'
+      def logout
+        Authentication.logout
+      end
+
+      desc 'whoami', 'Info on current login'
+      def whoami
+        Authentication.whoami
+      end
+    end
+  end
+end

data/lib/gleis/cli/db.rb

@@ -0,0 +1,48 @@
+module Gleis
+  module CLI
+    # Database-related CLI subcommands
+    class Db < Thor
+      class_option :app, aliases: :a, type: :string, default: Utils.app_name
+
+      desc 'backup', 'Backup locally database DATABASE_URL'
+      def backup
+        Gleis::Database.backup(options[:app])
+      end
+
+      desc 'delete DB_ENV_VAR', 'Delete database configured at variable name'
+      def delete(env_var_name)
+        Gleis::Database.delete(options[:app], env_var_name)
+      end
+
+      desc 'info', 'Information about database DATABASE_URL'
+      def info
+        Gleis::Database.info(options[:app])
+      end
+
+      desc 'new', 'Create new database'
+      def new
+        Gleis::Database.new(options[:app])
+      end
+
+      desc 'promote DB_ENV_VAR', 'Promote database to app using variable name (e.g. DATABASE1_URL)'
+      def promote(env_var_name)
+        Gleis::Database.promote(options[:app], env_var_name)
+      end
+
+      desc 'psql', 'Connect to PostgreSQL database DATABASE_URL'
+      def psql
+        Gleis::Database.psql(options[:app])
+      end
+
+      desc 'push LOCAL_DB_NAME', 'Copy local database to remote database DATABASE_URL'
+      def push(local_name)
+        Gleis::Database.push(options[:app], local_name)
+      end
+
+      desc 'reset DB_ENV_VAR', 'Reset database configured at variable name'
+      def reset(env_var_name)
+        Gleis::Database.reset(options[:app], env_var_name)
+      end
+    end
+  end
+end

data/lib/gleis/cli/domain.rb

@@ -0,0 +1,23 @@
+module Gleis
+  module CLI
+    # Domain-related CLI commands
+    class Domain < Thor
+      class_option :app, aliases: :a, type: :string, default: Utils.app_name
+
+      desc 'add DOMAIN', 'Add domain name to app'
+      def add(name)
+        Gleis::Domain.add(options[:app], name)
+      end
+
+      desc 'list', 'List existing domain names for app'
+      def list
+        Gleis::Domain.list(options[:app])
+      end
+
+      desc 'remove DOMAIN', 'Remove domain name from app'
+      def remove(name)
+        Gleis::Domain.remove(options[:app], name)
+      end
+    end
+  end
+end

data/lib/gleis/cli/management.rb

@@ -0,0 +1,16 @@
+module Gleis
+  module CLI
+    # Management-related CLI commands
+    class Management < Thor
+      desc 'apps', 'List all apps for organisation'
+      def apps
+        Gleis::Management.apps
+      end
+
+      desc 'license', 'Display short license info'
+      def license
+        Gleis::Management.license
+      end
+    end
+  end
+end

data/lib/gleis/cli/sharing.rb

@@ -0,0 +1,23 @@
+module Gleis
+  module CLI
+    # Sharing-related CLI commands
+    class Sharing < Thor
+      class_option :app, aliases: :a, type: :string, default: Utils.app_name
+
+      desc 'add EMAIL ROLE', 'Allow user to access app (roles: collaborator, owner)'
+      def add(email, role)
+        Gleis::Sharing.add(options[:app], email, role)
+      end
+
+      desc 'list', 'Show access list of application'
+      def list
+        Gleis::Sharing.list(options[:app])
+      end
+
+      desc 'remove EMAIL', 'Remove user access to app'
+      def remove(email)
+        Gleis::Sharing.remove(options[:app], email)
+      end
+    end
+  end
+end

data/lib/gleis/cli/storage.rb

@@ -0,0 +1,28 @@
+module Gleis
+  module CLI
+    # Storage-related CLI commands
+    class Storage < Thor
+      class_option :app, aliases: :a, type: :string, default: Utils.app_name
+
+      desc 'add TYPE', 'Add storage to app'
+      def add(type)
+        Gleis::Storage.add(options[:app], type)
+      end
+
+      desc 'attach DIRECTORY', 'Attach storage to directory (e.g. /usr/src/app/public)'
+      def attach(dir)
+        Gleis::Storage.attach(options[:app], dir)
+      end
+
+      desc 'list', 'List available storage types'
+      def list
+        Gleis::Storage.list(options[:app])
+      end
+
+      desc 'sync DIRECTORY', 'Synchronise local directory with remote storage'
+      def sync(dir)
+        Gleis::Storage.sync(options[:app], dir)
+      end
+    end
+  end
+end

data/lib/gleis/config.rb

@@ -0,0 +1,21 @@
+module Gleis
+  # Global parameters of gleis gem and app config env variables
+  class Config
+    # Override default API URL if GLEIS_API_URL env variable is set
+    API_URL = ENV['GLEIS_API_URL'].nil? ? 'https://api.basel.gleis.one/' : ENV['GLEIS_API_URL']
+    API_VERSION = 'v0'.freeze
+    SSH_KEY_FILE_BASE = Dir.home + '/.ssh/gleis'
+    TOKEN_FILE = Dir.home + '/.gleis-token'
+
+    def self.get_env_vars(app_name, token)
+      body = API.request('get', "config/#{app_name}", token)
+      abort("Failed to get app environment variables: #{body['error_text']}") if body['success'] != 1
+      body
+    end
+
+    def self.get_env_var(app_name, token, var_name)
+      body = API.request('get', "config/#{app_name}/#{var_name}", token)
+      return body['data'] if body['success'] == 1
+    end
+  end
+end