faastruby 0.4.18 → 0.5.0

data/lib/faastruby/cli/new_credentials.rb

@@ -0,0 +1,63 @@
+module FaaStRuby
+  module NewCredentials
+    require 'fileutils'
+    require 'yaml'
+    class CredentialsFile
+      def initialize
+        @folder = File.expand_path("~/.faastruby")
+        @file = "#{@folder}/credentials.yml"
+        rename_if_old_file_exists
+        create_credentials_folder
+      end
+
+      def rename_if_old_file_exists
+        old_file = File.expand_path("~/.faastruby")
+        return true unless File.file?(old_file)
+        new_file = File.expand_path("~/.faastruby.tor1")
+        FileUtils.mv(old_file, new_file)
+        return true
+      end
+
+      def create_credentials_folder
+        return true if File.file?(@file)
+        FileUtils.mkdir_p(@folder)
+        clear
+      end
+
+      def read
+        YAML.load(File.read(@file)) rescue {}
+      end
+
+      def get
+        creds = read['credentials'] || {}
+        unless creds['email'] && creds['api_key'] && creds['api_secret']
+          FaaStRuby::CLI.error("\nYou are not logged in. To login, run: faastruby login\n\nIf you don't have an account, run 'faastruby signup' to create one.\n", color: nil)
+        end
+        creds
+      end
+
+      def has_user_logged_in?
+        creds = read['credentials'] || {}
+        creds['email'] && creds['api_key'] && creds['api_secret']
+      end
+
+      def save(email:, api_key:, api_secret:)
+        yaml = {
+          'credentials' => {
+            'email' => email,
+            'api_key' => api_key,
+            'api_secret' => api_secret
+          }
+        }.to_yaml
+        File.write(@file, yaml)
+      end
+
+      def clear
+        yaml = {
+          'credentials' => {}
+        }.to_yaml
+        File.write(@file, yaml)
+      end
+    end
+  end
+end

data/lib/faastruby/cli/package.rb

@@ -1,3 +1,4 @@
+require 'zip'
 module FaaStRuby
   class Package
     # Initialize with the directory to zip and the location of the output archive.

data/lib/faastruby/cli/template.rb

@@ -12,7 +12,8 @@ module FaaStRuby
       @source = source
     end
 
-    def install(to:, force: false)
+    def install(to:, force: false, print_base_dir: false)
+      @output_prefix = print_base_dir ? "#{print_base_dir}/" : ""
       @target = to
       @force = force
       FaaStRuby::CLI.error("Could not determine the target path for template '#{type}:#{source}'. Please report this bug at https://github.com/FaaStRuby/faastruby-cli/issues", color: nil) unless target
@@ -40,12 +41,11 @@ module FaaStRuby
     end
 
     def install_from_folder(folder)
-      # puts "installing from folder #{folder}"
       if File.directory?(target)
-        puts "! d #{target}".yellow
+        puts "! d #{@output_prefix}#{target}".yellow
       else
         FileUtils.mkdir_p(target)
-        puts "+ d #{target}".green
+        puts "+ d #{@output_prefix}#{target}".green
       end
       Dir.glob("**/*", base: folder).each do |entry|
         full_source_path = "#{folder}/#{entry}"
@@ -58,10 +58,10 @@ module FaaStRuby
 
     def create_dir(dir)
       if File.directory?(dir)
-        puts "! d #{dir}".yellow
+        puts "! d #{@output_prefix}#{dir}".yellow
       else
         FileUtils.mkdir_p(dir)
-        puts "+ d #{dir}".green
+        puts "+ d #{@output_prefix}#{dir}".green
       end
     end
 
@@ -72,7 +72,7 @@ module FaaStRuby
         return(puts "[skipped] #{destination}") unless ['y', 'Y'].include?(answer)
       end
       FileUtils.cp(source, destination)
-      puts "+ f #{destination}".green
+      puts "+ f #{@output_prefix}#{destination}".green
     end
 
     def local?

data/lib/faastruby/local.rb

@@ -0,0 +1,188 @@
+module FaaStRuby
+  module Local
+    require 'listen'
+    require 'colorize'
+    require 'open3'
+    require 'oj'
+    require 'yaml'
+    require 'pathname'
+    require 'securerandom'
+    require 'faastruby/version'
+    require 'faastruby/supported_runtimes'
+    require 'faastruby/local/logger'
+    require 'faastruby/local/functions'
+    require 'faastruby/local/static_files'
+    require 'faastruby/local/listeners'
+    require 'faastruby/local/processors'
+    require 'faastruby/local/monkey_patch'
+    extend Local::Logger
+
+    def self.get_crystal_version
+      debug "self.get_crystal_version"
+      ver = `crystal -v|head -n1|cut -f2 -d' ' 2>/dev/null`&.chomp
+      ver == '' ? CRYSTAL_LATEST : ver
+    end
+
+    def self.crystal_present_and_supported?
+      debug "self.crystal_present_and_supported?"
+      system("which crystal >/dev/null") && SUPPORTED_CRYSTAL.include?(get_crystal_version)
+    end
+
+    def self.ruby_present_and_supported?
+      debug "self.ruby_present_and_supported?"
+      system("which ruby >/dev/null") && SUPPORTED_RUBY.include?(RUBY_VERSION)
+    end
+
+    def self.check_if_logged_in
+      creds_file = File.expand_path("~/.faastruby/credentials.yml")
+      yaml = YAML.load(File.read(creds_file)) rescue {}
+      unless yaml['credentials'] && yaml['credentials']['email']
+        STDOUT.puts "@@@ WARNING @@@ | You need to be logged in to use FaaStRuby Local with sync mode.".red
+        STDOUT.puts "@@@ WARNING @@@ | To login, run: faastruby login".red
+        STDOUT.puts "@@@ WARNING @@@ | Sync mode is *NOT* enabled!".red
+        STDOUT.puts "---".red
+        return false
+      end
+      return true
+    end
+
+    DEBUG = ENV['DEBUG']
+    CRYSTAL_ENABLED = crystal_present_and_supported?
+    RUBY_ENABLED = ruby_present_and_supported?
+    unless RUBY_ENABLED || CRYSTAL_ENABLED
+      puts "\n[ERROR] You need to have one of the following 'language:version' pairs in order to use FaaStRuby Local."
+      puts SUPPORTED_RUNTIMES.join(', ') + "\n"*2
+      exit 1
+    end
+    SERVER_ROOT = Dir.pwd
+    PROJECT_YAML_FILE = "#{SERVER_ROOT}/project.yml"
+    SECRETS_YAML_FILE = "#{SERVER_ROOT}/secrets.yml"
+    DEPLOY_ENVIRONMENT = ENV['DEPLOY_ENVIRONMENT'] || 'stage'
+    SYNC_ENABLED = ENV['SYNC'] && check_if_logged_in
+    CRYSTAL_VERSION = get_crystal_version.freeze
+    DEFAULT_CRYSTAL_RUNTIME = "crystal:#{CRYSTAL_VERSION}".freeze
+    DEFAULT_RUBY_RUNTIME = "ruby:#{RUBY_VERSION}".freeze
+    FUNCTIONS_EVENT_QUEUE = Queue.new
+    PUBLIC_EVENT_QUEUE = Queue.new
+
+    def self.workspace
+      debug "self.workspace"
+      return "#{project_config['name']}-#{DEPLOY_ENVIRONMENT}-#{project_config['identifier']}" if project_config['identifier']
+      "#{project_config['name']}-#{DEPLOY_ENVIRONMENT}"
+    end
+
+    def self.project_config
+      debug "self.project_config"
+      yaml = YAML.load(File.read(PROJECT_YAML_FILE))['project']
+    end
+    def self.functions_dir
+      debug "self.functions_dir"
+      "#{SERVER_ROOT}/#{project_config['functions_dir'] || 'functions'}"
+    end
+
+    def self.public_dir
+      debug "self.public_dir"
+      "#{SERVER_ROOT}/#{project_config['public_dir'] || 'public'}"
+    end
+
+    def self.root_to
+      debug "self.root_to"
+      project_config['root_to'] || 'root'
+    end
+
+    def self.catch_all
+      debug "self.catch_all"
+      project_config['catch_all'] || 'catch-all'
+    end
+
+    def self.functions
+      debug "self.functions"
+      @@functions ||= []
+    end
+
+    def self.functions_listener
+      debug "self.functions_listener"
+      @@functions_listener
+    end
+
+    def self.public_listener
+      debug "self.public_listener"
+      @@public_listener
+    end
+
+    def self.secrets_for_function(function_name)
+      debug "self.secrets_for_function(#{function_name.inspect})"
+      deploy_environment_secrets[function_name] || {}
+    end
+
+    def self.deploy_environment_secrets
+      debug "self.deploy_environment_secrets"
+      secrets[DEPLOY_ENVIRONMENT] || {}
+    end
+
+    def self.secrets
+      debug "self.secrets"
+      YAML.load(File.read(SECRETS_YAML_FILE))['secrets'] || {}
+    end
+
+    def self.start!
+      Listen::Adapter::Linux::DEFAULTS[:events] << :modify
+      debug "self.start!"
+      sync_mode_enabled if SYNC_ENABLED
+      @@functions = Function.find_all_in(functions_dir)
+      ruby_functions = @@functions.map{|f| f.name if f.language == "ruby"}.compact
+      crystal_functions = @@functions.map{|f| f.name if f.language == "crystal"}.compact
+      puts "Detecting existing functions."
+      puts "Ruby functions: #{ruby_functions.inspect}"
+      puts "Crystal functions: #{crystal_functions.inspect}"
+      listen_on_functions_dir
+      listen_on_public_dir if SYNC_ENABLED
+      initial_compile_and_deploy(crystal_functions)
+      puts "Listening for changes."
+      FunctionProcessor.new(FUNCTIONS_EVENT_QUEUE).start
+      StaticFileProcessor.new(PUBLIC_EVENT_QUEUE).start if SYNC_ENABLED
+      sleep
+    end
+
+    def self.initial_compile_and_deploy(crystal_functions)
+      debug "initial_compile_and_deploy(#{crystal_functions.inspect})"
+      puts "Triggering 'compile' on Crystal functions." if crystal_functions.any?
+      if SYNC_ENABLED
+        puts "Running initial cloud sync."
+        StaticFile.full_sync
+      end
+      sleep 1
+      @@functions.each {|f| FileUtils.touch("#{f.absolute_folder}/faastruby.yml")}
+    end
+
+    def self.sync_mode_enabled
+      debug __method__
+      puts "Sync mode enabled."
+      print "Connecting to workspace '#{workspace}'... "
+      try_to_create = Proc.new {system("faastruby create-workspace #{workspace}")}
+      has_credentials = system("faastruby list-workspace #{workspace} > /dev/null 2>&1")
+      continue = has_credentials || try_to_create.call
+      unless continue
+        puts "[FATAL] Unable to setup project workspace '#{workspace}'. Make sure you have the credentials, or try a different environment name.\nExample: faastruby local --sync --deploy-env #{DEPLOY_ENVIRONMENT}-#{(rand * 100).to_i}".red
+        exit 1
+      end
+      STDOUT.puts "connected!\n".yellow
+      puts "Your local environment will be synced to https://#{workspace}.tor1.faast.cloud"
+      true
+    end
+
+    def self.listen_on_functions_dir
+      debug "self.listen_on_functions_dir"
+      debug "Listening for changes in '#{functions_dir}'"
+      @@functions_listener = Listener.new(directory: functions_dir, queue: FUNCTIONS_EVENT_QUEUE)
+      @@functions_listener.start
+    end
+
+    def self.listen_on_public_dir
+      debug "self.listen_on_public_dir"
+      debug "Listening for changes in '#{public_dir}'"
+      @@public_listener = Listener.new(directory: public_dir, queue: PUBLIC_EVENT_QUEUE)
+      @@public_listener.start
+    end
+  end
+end

data/lib/faastruby/local/crystal_runtime.cr

@@ -0,0 +1,170 @@
+require "base64"
+require "json"
+require "yaml"
+
+module FaaStRuby
+  macro require_handler
+    require {{env("HANDLER_PATH")}}
+  end
+  class Event
+    JSON.mapping(
+      body: String?,
+      headers: Hash(String, String | Nil),
+      context: String?,
+      query_params: Hash(String, String | Nil)
+    )
+  end
+
+  class Response
+    @@rendered = false
+    property "body"
+    property "status"
+    property "headers"
+    property "io"
+    property "binary"
+    def initialize(@body : String?, @status : Int32, @headers : Hash(String, String), @binary : Bool = false)
+      @io = nil
+    end
+
+    def initialize(@io : Bytes, @status : Int32, @headers : Hash(String, String), @binary : Bool = true)
+    end
+
+    def payload
+      if io
+        hash = {
+          "response" => Base64.encode(io.not_nil!),
+          "status" => status,
+          "headers" => headers,
+          "binary" => binary
+        }
+      else
+        hash = {
+          "response" => body,
+          "status" => status,
+          "headers" => headers,
+          "binary" => binary
+        }
+      end
+      hash
+    end
+  end
+  class Payload
+    JSON.mapping(
+      args: Array(JSON::Any)?,
+      event: Event
+    )
+  end
+  module Function
+    def self.run(@@event : Event)
+      begin
+        output = handler(event)
+      rescue e
+        backtrace = e.backtrace.reverse.join("\n")
+        puts backtrace
+        puts "#{e.class.name}: #{e.message}"
+        output = render json: {"error" => e.message, "location" => backtrace}.to_json, status: 500
+      end
+    end
+  end
+end
+
+FaaStRuby.require_handler
+
+def render(icon : String? = nil, jpeg : String? = nil, gif : String? = nil, png : String? = nil, io : Bytes? = nil, css : String? = nil, svg : String? = nil, js : String? = nil, inline : String? = nil, html : String? = nil, json : String? = nil, yaml : String? = nil, text : String? = nil, status : Int32 = 200, headers : Hash(String, String) = {} of String => String, content_type : String? = nil, binary : Bool = false)
+  headers["Content-Type"] = content_type if content_type
+  bin = false
+  case
+  when json
+    headers["Content-Type"] ||= "application/json"
+    resp_body = json
+  when html, inline
+    headers["Content-Type"] ||= "text/html"
+    resp_body = html
+  when text
+    headers["Content-Type"] ||= "text/plain"
+    resp_body = text
+  when yaml
+    headers["Content-Type"] ||= "text/yaml"
+    resp_body = yaml
+  when js
+    headers["Content-Type"] ||= "text/javascript"
+    resp_body = js
+  when io
+    headers["Content-Type"] ||= "application/octet-stream"
+    bin = binary
+    return FaaStRuby::Response.new(io: io, status: status, headers: headers, binary: bin)
+  when png
+    headers["Content-Type"] ||= "image/png"
+    file = File.open(png, "rb"){|f| f.gets_to_end}
+    resp_body = Base64.urlsafe_encode(file, false)
+    bin = true
+  when svg
+    headers["Content-Type"] ||= "image/svg+xml"
+    resp_body = svg
+  when jpeg
+    headers["Content-Type"] ||= "image/jpeg"
+    file = File.open(jpeg, "rb"){|f| f.gets_to_end}
+    resp_body = Base64.urlsafe_encode(file, false)
+    bin = true
+  when gif
+    headers["Content-Type"] ||= "image/gif"
+    file = File.open(gif, "rb"){|f| f.gets_to_end}
+    resp_body = Base64.urlsafe_encode(file, false)
+    bin = true
+  when icon
+    headers["Content-Type"] ||= "image/x-icon"
+    file = File.read(icon)
+    resp_body = Base64.urlsafe_encode(file, false)
+    bin = true
+  when css
+    headers["Content-Type"] ||= "text/css"
+    resp_body = css
+  end
+  FaaStRuby::Response.new(body: resp_body, status: status, headers: headers, binary: bin)
+end
+
+def redirect_to(function : String, status : Int32 = 303)
+  headers = {"Location" => function}
+  FaaStRuby::Response.new(body: nil, status: status, headers: headers)
+end
+
+def redirect_to(url : String, status : Int32 = 303)
+  headers = {"Location" => url}
+  FaaStRuby::Response.new(body: nil, status: status, headers: headers)
+end
+
+def respond_with(body : String? = nil, status : Int32 = 200, headers : Hash(String, String) = {} of String => String, binary : Bool = false)
+  FaaStRuby::Response.new(body: body, status: status, headers: headers)
+end
+
+def respond_with(io : Bytes, status : Int32 = 200, headers : Hash(String, String) = {} of String => String, binary : Bool = false)
+  FaaStRuby::Response.new(io: io, status: status, headers: headers, binary: binary)
+end
+
+def error(msg : String, status : Int32)
+  hash = {
+    "response" => msg,
+    "status" => status,
+    "headers" => {"Content-Type" => "application/json"}
+  }
+  puts "R,#{Base64.urlsafe_encode(hash.to_json, false)}"
+  exit 1
+end
+encoded_input = STDIN.gets.not_nil!.chomp
+begin
+  decoded_input = Base64.decode_string(encoded_input)
+  payload = FaaStRuby::Payload.from_json(decoded_input)
+rescue e
+  puts e.message
+  error(msg: "Runtime Error. What are you trying to do?", status: 500)
+  exit 1
+end
+spawn do
+  response = FaaStRuby::Function.run(event: payload.event)
+  puts "R,#{Base64.urlsafe_encode(response.payload.to_json)}"
+  exit 0
+end
+max_time = ENV["MAX_EXECUTION_TIME"]? ? ENV["MAX_EXECUTION_TIME"].not_nil!.to_f : 60.0
+sleep max_time
+error(msg: "Execution expired", status: 504)
+exit 1