afterlife 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8dfb530dade840c8e03042de3ba5508eec1002830c0b978ab42aa1f88b83fab
+  data.tar.gz: 39452459ace3d25eb5270e0e83295e0919f97b11813128b98a6deb39b407431b
+SHA512:
+  metadata.gz: 30fb609ce63cd5038050a2afae03741fd9d8739d4d014cfbd85ca09a0c1f44a9eb3521b85866b64763bfeea287891ea6d00c84491bf39f4bbf6cea152b8ef8d5
+  data.tar.gz: e94831df012dfe22f833e277b0fbc5b6c11ae5c9c85d9897068d14b05171c4ab7fd542b2f578d0c95fd17feef9419e0c7abb8aeb50421b29e9e93322bd17fa47

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,46 @@
+require:
+  - rubocop-rspec
+  - rubocop-rake
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.7
+
+Lint/ConstantDefinitionInBlock:
+  Enabled: false
+
+Layout/IndentationConsistency:
+  Enabled: false
+
+Layout/HashAlignment:
+  Enabled: false
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: false
+
+Style/HashAsLastArrayItem:
+  EnforcedStyle: no_braces
+
+Style/OptionalBooleanParameter:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Layout/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Style/SignalException:
+  EnforcedStyle: semantic

data/.ruby-gemset

@@ -0,0 +1 @@
+afterlife

data/.ruby-version

@@ -0,0 +1 @@
+3.0.5

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-01-13
+
+- Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in afterlife.gemspec
+gemspec
+
+gem 'pry'
+
+gem 'rake'
+
+gem 'rspec'
+
+gem 'rubocop'
+gem 'rubocop-rake'
+gem 'rubocop-rspec'

data/README.md

@@ -0,0 +1,30 @@
+# Afterlife
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/afterlife`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text abovxe, and describe your gem
+
+## Installation
+
+1. Execute `bin/install` in the repository root
+2. Put a `env.yml` on ~/.afterlife/env.yml based on the AWS credentials found on mifiel's bitwarden vault
+3. Install AWS CLI following the [official guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+
+## Usage
+Run `afterlife help` for a list of all available commands
+
+
+## About CDN
+Logs can be found on `~/.afterlife/logs/cdn.log`
+
+Running `afterlife cdn start` will run the CDN web server in the background. Running in foreground using `afterlife cdn start --foreground` will display errors and content normally found in logs in console instead.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/afterlife.

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+desc 'start a console'
+task :console do
+  exec 'pry -r afterlife -I ./lib'
+end
+
+task default: %i[spec rubocop]

data/afterlife.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'lib/afterlife/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'afterlife'
+  spec.version = Afterlife::VERSION
+  spec.authors = ['Genaro Madrid']
+  spec.email = ['genmadrid@gmail.com']
+
+  spec.summary = 'Devops tools for Mifiel'
+  spec.description = 'Afterlife helps you setup your development environment and deploy code easily'
+  spec.required_ruby_version = '>= 2.6'
+
+  spec.metadata['source_code_uri'] = 'https://bitbucket.org/volabit/afterlife'
+  spec.metadata['changelog_uri'] = 'https://bitbucket.org/volabit/afterlife/src/master/CHANGELOG.md'
+
+  # 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.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'git'
+  spec.add_dependency 'puma'
+  spec.add_dependency 'rackup'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'zeitwerk'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/config.ru

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'rack/directory'
+
+logger_file = File.open(Afterlife::Cdn.log_path, 'a')
+logger_file.sync = true
+
+class AssetHeaders
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    response = @app.call(env)
+    response[1]['access-control-allow-origin'] = '*'
+    response
+  end
+end
+
+use AssetHeaders
+use Rack::CommonLogger, Logger.new(logger_file)
+run do |env|
+  Rack::Directory.new(Afterlife::Cdn.local_path).call(env)
+end

data/exe/afterlife

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_dir = File.expand_path('../lib', __dir__)
+require "#{lib_dir}/afterlife"
+
+Afterlife.root = Pathname(File.expand_path('..', __dir__))
+Afterlife::Cli.start

data/lib/afterlife/base_cli.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Afterlife
+  module BaseCli
+    def log_success(message)
+      say set_color(message, :green)
+      say "\n"
+    end
+
+    def log_error(message)
+      say set_color(message, :red)
+      say "\n"
+    end
+
+    def log_info(message)
+      say set_color(message, :cyan)
+      say "\n"
+    end
+
+    def log_interrupted
+      say ''
+      fatal! 'Interrupted'
+    end
+
+    def sure?(msg)
+      say msg
+      return true if yes?('Are you sure? [y/n]')
+
+      fatal! 'Good bye'
+    end
+
+    def fatal!(msg)
+      log_error "ERROR: #{msg}"
+      exit 1
+    end
+  end
+end

data/lib/afterlife/bump/semver.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Bump
+    module Semver
+    module_function
+
+      DEFAULT_PRERELEASE_NAME = 'rc'
+      VERSION_REGEX = /(\d+\.\d+\.\d+(?:-(?:.+))?)/.freeze
+
+      def calculate_next(part, pre = nil) # rubocop:disable Metrics/MethodLength
+        x, y, z = release
+        case part.to_sym
+        when :major
+          "#{x + 1}.0.0"
+        when :minor
+          "#{x}.#{y + 1}.0"
+        when :patch
+          "#{x}.#{y}.#{z + 1}"
+        when :pre
+          name, ver = parse_prerelease(pre)
+          "#{x}.#{y}.#{z}-#{name}.#{ver + 1}"
+        end
+      end
+
+      def parse_prerelease(name)
+        curr_name, curr_ver = curr_prerelease
+
+        if name
+          # if the user specifies a name different than the current one, reseting the current version
+          curr_ver = -1 if name != curr_name
+          curr_name = name
+        end
+
+        [curr_name, curr_ver]
+      end
+
+      def release
+        version_chunks[0].split('.').map(&:to_i)
+      end
+
+      def curr_prerelease
+        return [DEFAULT_PRERELEASE_NAME, -1] unless version_chunks[1]
+
+        name, ver = version_chunks[1].split('.')
+        [name, ver.to_i]
+      end
+
+      def version_chunks
+        @version_chunks ||= version.split('-')
+      end
+
+      def version
+        result = %x(git describe --tags `git rev-list --tags --max-count=1`).chomp
+        # remove the first 'v' if exists, all mifiel tags always have it
+        result[0] == 'v' ? result[1..] : result
+      end
+    end
+  end
+end

data/lib/afterlife/bump.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Bump
+  end
+end

data/lib/afterlife/cdn/cli.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Afterlife
+  module Cdn
+    class Cli < Thor
+      include BaseCli
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'start', 'Start the CDN server'
+      option :port,
+             type: :numeric,
+             aliases: '-p',
+             default: 5000
+      option :foreground,
+             type: :boolean,
+             aliases: '-f'
+      option 'no-link', type: :boolean
+      def start
+        Cdn.link unless options['no-link']
+        say_status 'Starting', "http://localhost:#{options[:port]}"
+        Cdn::Server.start(options.symbolize_keys.slice(:port, :foreground))
+        log_success "The server started at http://localhost:#{options[:port]}"
+      rescue Afterlife::Error => e
+        log_error(e)
+      end
+
+      desc 'stop', 'stop the CDN server'
+      def stop
+        say_status 'Stopping', nil
+        Server.kill
+        log_success 'The server stopped'
+      rescue Afterlife::Error => e
+        log_error(e)
+      end
+
+      desc 'restart', 'restart the CDN server'
+      def restart
+        invoke :stop if Server.running?
+        invoke :start
+      end
+
+      desc 'logs', 'tail the logs of the CDN server'
+      def logs
+        exec("tail -f #{Afterlife::Cdn.log_path}")
+      end
+
+      desc 'link', 'create symlinks in .cdn directory. ' \
+                   'Usually you dont need to run this script by itself'
+      def link
+        Cdn.link
+        log_success('Repos successfully linked to local CDN path')
+      end
+    end
+  end
+end

data/lib/afterlife/cdn/server.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rackup'
+
+module Afterlife
+  module Cdn
+    class Server
+      attr_reader :instance
+
+      def self.pid_file
+        Afterlife.local_path.join('pids/server.pid')
+      end
+
+      def self.kill
+        fail Afterlife::Error, 'The server is not running' unless running?
+
+        Process.kill('INT', pid_file.read.to_i)
+      end
+
+      def self.start(args)
+        fail Afterlife::Error, 'A server is already running' if running?
+
+        new(args).start
+      end
+
+      def self.running?
+        pid_file.exist?
+      end
+
+      def initialize(args)
+        @instance = Rackup::Server.new(
+          environment: ENV['RACK_ENV'] || 'development',
+          quiet: true, # we setup log in config.ru
+          Port: args[:port],
+          config: Afterlife.root.join('config.ru').to_s,
+          pid: Server.pid_file.to_s,
+          daemonize: !args[:foreground],
+        )
+      end
+
+      def start
+        instance.start
+      end
+    end
+  end
+end

data/lib/afterlife/cdn.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Cdn
+  module_function
+
+    def url(repo = nil)
+      return Afterlife.current_stage.cdn_url unless repo
+
+      "#{url}/#{repo.full_name}"
+    end
+
+    def log_path
+      Afterlife.local_path.join('logs/cdn.log')
+    end
+
+    def local_path
+      Afterlife.local_path.join('cdn')
+    end
+
+    def link
+      FileUtils.rm_rf(Afterlife::Cdn.local_path)
+      FileUtils.mkdir_p(Afterlife::Cdn.local_path)
+      Repo.all.each do |repo|
+        dest = Afterlife::Cdn.local_path.join(repo.full_name)
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.ln_sf(repo.dist_path, dest)
+      end
+    end
+  end
+end

data/lib/afterlife/cli.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Afterlife
+  class Cli < Thor
+    include BaseCli
+    def self.exit_on_failure?
+      true
+    end
+
+    package_name 'Afterlife'
+    class_option :quiet, type: :boolean, group: :runtime
+    class_option :verbose, type: :boolean, group: :runtime
+
+    desc 'init', 'Init afterlife'
+    def init
+      FileUtils.mkdir_p(Afterlife.local_path.join('logs'))
+      FileUtils.mkdir_p(Afterlife.local_path.join('pids'))
+      FileUtils.mkdir_p(Afterlife::Cdn.local_path)
+      FileUtils.touch(Afterlife::Config.file)
+      log_success 'afterlife is ready!'
+    end
+
+    desc 'config <path>', 'get config options'
+    def config(path) # rubocop:disable Metrics/MethodLength
+      path = path.split('.').map(&:to_sym)
+      result = repo.conf.dig(*path)
+      case result
+      when Hash
+        say JSON.generate(result)
+      when Array
+        result.each do |item|
+          say item
+        end
+      else
+        say result
+      end
+    end
+
+    desc 'cdn', 'CDN stuff'
+    subcommand 'cdn', Cdn::Cli
+
+    desc 'deploy <stage>', 'Deploy current directory'
+    option 'no-build', type: :boolean
+    option 'no-install', type: :boolean
+    option 'dry-run', type: :boolean
+    option 'skip-after-hooks', type: :boolean
+    option :yes, type: :boolean
+    # this only has logic for CDN deployments
+    # TODO: Add logic for different deployment types
+    def deploy(stage) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      Afterlife.cli = self
+      Afterlife.current_stage = Afterlife.config.stages[stage.to_sym]
+      fill_env
+      ask_confirmation(repo.confirmation_message) unless options['yes']
+      install_dependencies unless options['no-install']
+      build unless options['no-build']
+
+      say_status 'Deploying', repo.dist_path
+      output = Deploy.call
+      say_status 'Deployed', output
+    rescue Deploy::Error => e
+      fatal!(e.message)
+    rescue Interrupt
+      log_interrupted
+    end
+
+    desc 'release', 'Releases management'
+    subcommand 'release', Release::Cli
+
+    map %w[-v --version] => :version
+    desc 'version', 'Prints afterlife version'
+    def version
+      say Afterlife::VERSION
+    end
+
+  private
+
+    def fill_env
+      repo.env.merge!(
+        'DIST_PATH' => repo.dist_path.to_s,
+        'CURRENT_BRANCH' => repo.current_branch,
+        'AFTERLIFE_STAGE' => Afterlife.current_stage.name,
+      )
+    end
+
+    def install_dependencies
+      return unless repo.install_dependencies_command
+
+      say_status 'Installing', '*' * 20
+      Exec.run(repo.install_dependencies_command)
+    end
+
+    def build
+      return unless repo.build_command
+
+      say_status 'Building', '*' * 20
+      Exec.run(repo.build_command)
+    end
+
+    def ask_confirmation(message)
+      if message
+        say message
+      else
+        say set_color("You're about to deploy the contents of '#{repo.dist_path}' to")
+        say set_color(Cdn.url(repo), :bold)
+        say set_color("\nWARNING: Please be aware that this may be a destructive operation", :yellow)
+      end
+      exit 1 unless yes?('Are you sure? [y/n]')
+    end
+
+    def repo
+      Afterlife.current_repo
+    end
+  end
+end

data/lib/afterlife/config.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Afterlife
+  class Config
+    def self.file
+      Afterlife.local_path.join('config.yml')
+    end
+
+    def respond_to_missing?(sym, include_all)
+      config.key?(sym) || super
+    end
+
+    def method_missing(sym, *args, &block)
+      config.key?(sym) ? config[sym] : super
+    end
+
+    def stages
+      @stages ||= config.delete(:stages)&.to_h do |name, val|
+        [name, Stage.new(val.merge(name: name.to_s))]
+      end
+    end
+
+  private
+
+    def config
+      @config ||= YAML.load_file(Config.file).deep_symbolize_keys
+    end
+  end
+end

data/lib/afterlife/deploy/cdn_deployment.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Afterlife
+  class Deploy
+    class CdnDeployment < Deployment
+      def run
+        Exec.run(commands)
+        Cdn.url(repo)
+      end
+
+      def setup
+        repo.env.merge!(
+          'AWS_PROFILE' => Afterlife.config.credentials.dig(:aws, :profile),
+          'AWS_BUCKET' => Afterlife.current_stage.bucket,
+          'AWS_REGION' => Afterlife.current_stage.region,
+          'S3_FULL_PATH' => s3_full_path,
+        )
+      end
+
+    private
+
+      def commands
+        [
+          repo_command || javascripts,
+          revision,
+        ].flatten
+      end
+
+      def javascripts
+        # by default we use no-cache, if something else is needed
+        # do it in the deploy.command option
+        <<-BASH
+          aws s3 sync
+            %<DIST_PATH>s
+            %<S3_FULL_PATH>s
+            --exclude '*.ts'
+            --exclude '*.tsx'
+            --cache-control 'no-cache'
+        BASH
+      end
+
+      def revision
+        <<-BASH
+          echo "#{repo.current_revision}" | aws s3 cp --content-type text/plain - %<S3_FULL_PATH>s/revision
+        BASH
+      end
+
+      def s3_full_path
+        "s3://#{Afterlife.current_stage.bucket}/#{repo.full_name}"
+      end
+    end
+  end
+end

data/lib/afterlife/deploy/deployment.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Afterlife
+  class Deploy
+    class Deployment
+      def self.run
+        deployment = new.tap(&:setup)
+        deployment.run
+      end
+
+      def run
+        fail NotImplementedError
+      end
+
+      def repo_command
+        Array(repo.conf.dig(:deploy, :command))
+      end
+
+      def setup; end
+
+    protected
+
+      def repo
+        Afterlife.current_repo
+      end
+    end
+  end
+end