fastlyctl 1.0.1

data/lib/fastlyctl/commands/snippet.rb

@@ -0,0 +1,105 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "snippet ACTION NAME", "Manipulate snippets on a service. Available actions are create, delete, and list. Use upload command to update snippets."
+    method_option :service, :aliases => ["--s"]
+    method_option :version, :aliases => ["--v"]
+    method_option :type, :aliases => ["--t"]
+    method_option :dynamic, :aliases => ["--d"]
+    def snippet(action,name=false)
+      id = FastlyCTL::Utils.parse_directory unless options[:service]
+      id ||= options[:service]
+
+      abort "Could not parse service id from directory. Use --s <service> to specify, vcl download, then try again." unless id
+
+      version = FastlyCTL::Fetcher.get_writable_version(id) unless options[:version]
+      version ||= options[:version].to_i
+
+      filename = "#{name}.snippet"
+
+      case action
+      when "upload"
+        abort "Must supply a snippet name as second parameter" unless name
+
+        abort "No snippet file for #{name} found locally" unless File.exists?(filename)
+
+        active_version = FastlyCTL::Fetcher.get_active_version(id)
+
+        snippets = FastlyCTL::Fetcher.get_snippets(id, active_version)
+
+        abort "No snippets found in active version" unless snippets.is_a?(Array) && snippets.length > 0
+
+        snippet = false
+        snippets.each do |s|
+          if s["name"] == name
+            abort "This command is for dynamic snippets only. Use vcl upload for versioned snippets" if s["dynamic"] == "0"
+
+            snippet = s
+          end
+        end
+
+        abort "No snippet named #{name} found on active version" unless snippet
+
+        # get the snippet from the dynamic snippet api endpoint so you have the updated content
+        snippet = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/snippet/#{snippet["id"]}")
+
+        new_content = File.read(filename)
+
+        say(FastlyCTL::Utils.get_diff(snippet["content"],new_content))
+
+        abort unless yes?("Given the above diff between the old dyanmic snippet content and the new content, are you sure you want to upload your changes? REMEMBER, THIS SNIPPET IS VERSIONLESS AND YOUR CHANGES WILL BE LIVE IMMEDIATELY!")
+
+        FastlyCTL::Fetcher.api_request(:put, "/service/#{id}/snippet/#{snippet["snippet_id"]}", {:endpoint => :api, body: {
+            content: new_content
+          }
+        })
+
+        say("New snippet content for #{name} uploaded successfully")
+      when "create"
+        abort "Must supply a snippet name as second parameter" unless name
+
+        content = "# Put snippet content here."
+
+        FastlyCTL::Fetcher.api_request(:post,"/service/#{id}/version/#{version}/snippet",{
+          params: {
+            name: name,
+            type: options[:type] ? options[:type] : "recv",
+            content: content,
+            dynamic: options.key?(:dynamic) ? 1 : 0
+          }
+        })
+        say("#{name} created on #{id} version #{version}")
+
+        unless File.exists?(filename)
+          File.open(filename, 'w+') {|f| content }
+          say("Blank snippet file created locally.")
+          return
+        end
+
+        if yes?("Local file #{filename} found. Would you like to upload its content?")
+          FastlyCTL::Fetcher.upload_snippet(id,version,File.read(filename),name)
+          say("Local snippet file content successfully uploaded.")
+        end
+      when "delete"
+        abort "Must supply a snippet name as second parameter" unless name
+
+        FastlyCTL::Fetcher.api_request(:delete,"/service/#{id}/version/#{version}/snippet/#{name}")
+        say("#{name} deleted on #{id} version #{version}")
+
+        return unless File.exists?(filename)
+
+        if yes?("Would you like to delete the local file #{name}.snippet associated with this snippet?")
+          File.delete(filename)
+          say("Local snippet file #{filename} deleted.")
+        end
+      when "list"
+        snippets = FastlyCTL::Fetcher.api_request(:get,"/service/#{id}/version/#{version}/snippet")
+        say("Listing all snippets for #{id} version #{version}")
+        snippets.each do |d|
+          say("#{d["name"]}: Subroutine: #{d["type"]}, Dynamic: #{d["dynamic"]}")
+        end
+      else
+        abort "#{action} is not a valid command"
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/token.rb

@@ -0,0 +1,53 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "token ACTION", "Manipulate API tokens. Available actions are list, create, and delete. Scope defaults to admin:write. Options are --scope and --services. --services should be a comma separated list of services to restrict this token to."
+    method_option :customer, :aliases => ["--c"]
+    method_option :services, :aliases => ["--s"]
+    option :scope
+    def token(action)
+      case action
+      when "list"
+        if options[:customer]
+          tokens = FastlyCTL::Fetcher.api_request(:get, "/customer/#{options[:customer]}/tokens")
+        else
+          tokens = FastlyCTL::Fetcher.api_request(:get, "/tokens")
+        end
+        abort "No tokens to display!" unless tokens.length > 0
+
+        pp tokens
+
+      when "create"
+        scope = options[:scope]
+        scope ||= "global"
+
+        say("You must login again to create tokens.")
+
+        login_results = FastlyCTL::Fetcher.login
+
+        name = ask("What would you like to name your token?")
+
+        o = {
+          user: login_results[:user],
+          pass: login_results[:pass],
+          code: login_results[:code],
+          scope: scope,
+          name: name
+        }
+
+        o[:services] = options[:services].split(",") if options[:services]
+
+        o[:customer] = options[:customer] if options[:customer]
+
+        resp = FastlyCTL::Fetcher.create_token(o)
+
+      when "delete"
+        id = ask("What is the ID of the token you'd like to delete?")
+
+        FastlyCTL::Fetcher.api_request(:delete, "/tokens/#{id}", expected_responses: [204])
+        say("Token with id #{id} deleted.")
+      else
+        abort "#{action} is not a valid command"
+      end
+    end
+  end
+end

data/lib/fastlyctl/commands/upload.rb

@@ -0,0 +1,155 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "upload", "Uploads VCL in the current directory to the service."
+    method_option :version, :aliases => ["--v"]
+    method_option :comment, :aliases => ["--c"]
+    def upload
+      id = FastlyCTL::Utils.parse_directory
+
+      abort "Could not parse service id from directory. Use -s <service> to specify, vcl download, then try again." unless id
+
+      vcls = {}
+      snippets = {}
+
+      Dir.foreach(Dir.pwd) do |p|
+        next unless File.file?(p)
+        if p =~ /\.vcl$/
+          vcls[p.chomp(".vcl")] = {"content" => File.read(p), "name" => p.chomp(".vcl")}
+          next
+        end
+
+        if (p =~ /\.snippet$/)
+          snippets[p.chomp(".snippet")] = {"content" => File.read(p), "name" => p.chomp(".snippet")}
+        end
+      end
+
+      writable_version = FastlyCTL::Fetcher.get_writable_version(id) unless options[:version]
+      writable_version ||= options[:version].to_i
+      active_version = FastlyCTL::Fetcher.get_active_version(id);
+
+      old_vcls = FastlyCTL::Fetcher.get_vcl(id, active_version)
+      old_snippets = FastlyCTL::Fetcher.get_snippets(id, active_version)
+      old_snippets_writable = FastlyCTL::Fetcher.get_snippets(id, writable_version)
+
+      main_found = false
+
+      old_vcls ||= {}
+      old_vcls.each do |v|
+        next unless vcls.has_key? v["name"]
+        diff = FastlyCTL::Utils.get_diff(v["content"], vcls[v["name"]]["content"])
+
+        vcls[v["name"]]["matched"] = true
+        vcls[v["name"]]["new"] = false
+        main_found = vcls[v["name"]]["main"] = v["main"] == true ? true : false
+        vcls[v["name"]]["diff_length"] = diff.length
+
+        next if diff.length < 2
+
+        say(diff)
+      end
+
+      old_snippets ||= {}
+      old_snippets.each do |s|
+        next unless snippets.has_key? s["name"]
+        diff = FastlyCTL::Utils.get_diff(s["content"], snippets[s["name"]]["content"])
+
+        if s["dynamic"] == "1"
+          snippets[s["name"]]["skip_because_dynamic"] = true
+          next
+        end
+
+        snippets[s["name"]]["matched"] = true
+        snippets[s["name"]]["diff_length"] = diff.length
+
+        next if diff.length < 2
+
+        say(diff)
+      end
+      old_snippets_writable ||= {}
+      old_snippets_writable.each do |s|
+        next unless snippets.has_key? s["name"]
+        next if (old_snippets.select {|os| os["name"] == s["name"]}).length > 0
+
+        if s["dynamic"] == "1"
+          snippets[s["name"]]["skip_because_dynamic"] = true
+          next
+        end
+
+        snippets[s["name"]]["matched"] = true
+        snippets[s["name"]]["diff_length"] = 3
+
+        say(FastlyCTL::Utils.get_diff("",snippets[s["name"]]["content"]))
+      end
+
+      vcls.delete_if do |k,v|
+        if v["name"] == "generated"
+          next unless yes?("The name of this file is 'generated.vcl'. Please do not upload generated VCL back to a service. Are you sure you want to upload this file?")
+        end
+
+        if (v["matched"] == true)
+          #dont upload if the file isn't different from the old file
+          if (v["diff_length"] > 1)
+            false
+          else
+            true
+          end
+        elsif yes?("VCL #{v["name"]} does not currently exist on the service, would you like to create it?")
+          v["new"] = true
+          if !main_found
+            v["main"] = true 
+            main_found = true
+          end
+          say(FastlyCTL::Utils.get_diff("", v["content"]))
+          false
+        else 
+          say("Not uploading #{v["name"]}")
+          true
+        end
+      end
+
+      snippets.delete_if do |k,s|
+        if (s["matched"] == true)
+          #dont upload if the file isn't different from the old file
+          if (s["diff_length"] > 1)
+            false
+          else
+            true
+          end
+        else
+          if s.key?("skip_because_dynamic")
+            true
+          else
+            say("Not uploading #{s["name"]} because it does not exist on the service. Use the \"snippet create\" command to create it.")
+            true
+          end
+        end
+      end
+
+      abort unless yes?("Given the above diff, are you sure you want to upload your changes?")
+
+      vcls.each do |k,v|
+        FastlyCTL::Fetcher.upload_vcl(id, writable_version, v["content"], v["name"], v["main"], v["new"])
+
+        say("#{v["name"]} uploaded to #{id}")
+      end
+
+      snippets.each do |k,s|
+        FastlyCTL::Fetcher.upload_snippet(id, writable_version, s["content"], s["name"])
+
+        say("#{s["name"]} uploaded to #{id}")
+      end
+
+      if options.key?(:comment)
+        FastlyCTL::Fetcher.api_request(:put, "/service/#{id}/version/#{writable_version}",{
+          params: {comment: options[:comment]}
+        })
+      end
+
+      validation = FastlyCTL::Fetcher.api_request(:get, "/service/#{id}/version/#{writable_version}/validate")
+
+      abort "Compiler reported the following error with the generated VCL: #{validation["msg"]}" if validation["status"] == "error"
+
+      say("VCL(s) have been uploaded to version #{writable_version} and validated.")
+    end
+  end
+end

data/lib/fastlyctl/commands/watch.rb

@@ -0,0 +1,49 @@
+module FastlyCTL
+  class CLI < Thor
+    desc "watch POP", "Watch live stats on a service. Optionally specify a POP by airport code."
+    method_option :service, :aliases => ["--s"]
+    def watch(pop=false)
+      service = options[:service]
+      service ||= FastlyCTL::Utils.parse_directory
+
+      abort "Could not parse service id from directory. Use --s <service> to specify, vcl download, then try again." unless service
+
+      ts = false
+
+      pop = pop.upcase if pop
+
+      while true
+        data = FastlyCTL::Fetcher.api_request(:get,"/rt/v1/channel/#{service}/ts/#{ts ? ts : 'h/limit/120'}", :endpoint => :app)
+        
+        unless data["Data"].length > 0
+          say("No data to display!")
+          abort
+        end
+
+        if pop
+          unless data["Data"][0]["datacenter"].key?(pop)
+            abort "Could not locate #{pop} in data feed."
+          end
+          agg = data["Data"][0]["datacenter"][pop]
+        else 
+          agg = data["Data"][0]["aggregated"]
+        end
+
+        rps = agg["requests"]
+        # gbps
+        uncacheable = agg["pass"] + agg["synth"] + agg["errors"]
+        bw = ((agg["resp_header_bytes"] + agg["resp_body_bytes"]).to_f * 8.0) / 1000000000.0
+        hit_rate = (1.0 - ((agg["miss"] - agg["shield"]).to_f / ((agg["requests"] - uncacheable).to_f))) * 100.0
+        passes = agg["pass"]
+        miss_time = agg["miss"] > 0 ? ((agg["miss_time"] / agg["miss"]) * 1000).round(0) : 0
+        synth = agg["synth"]
+        errors = agg["errors"]
+
+        $stdout.flush
+        print " #{rps} req/s | #{bw.round(3)}gb/s | #{hit_rate.round(2)}% Hit Ratio | #{passes} passes/s | #{synth} synths/s | #{miss_time}ms miss time | #{errors} errors/s   \r"
+
+        ts = data["Timestamp"]
+      end
+    end
+  end
+end

data/lib/fastlyctl/fetcher.rb

@@ -0,0 +1,250 @@
+module FastlyCTL
+  module Fetcher
+    def self.api_request(method, path, options={})
+      options[:endpoint] ||= :api
+      options[:params] ||= {}
+      options[:headers] ||= {}
+      options[:body] ||= nil
+      options[:force_session] ||= false
+      options[:expected_responses] ||= [200]
+
+      headers = {"Accept" => "application/json", "Connection" => "close", "User-Agent" => "FastlyCTL: https://github.com/fastly/fastlyctl"}
+
+      if options[:endpoint] == :app
+        headers["Referer"] = FastlyCTL::FASTLY_APP
+        headers["X-CSRF-Token"] = FastlyCTL::Cookies["fastly.csrf"] if FastlyCTL::Cookies["fastly.csrf"]
+        headers["Fastly-API-Request"] = "true"
+      end
+
+      if FastlyCTL::Token && !options[:force_session]
+        headers["Fastly-Key"] = FastlyCTL::Token
+      else
+        headers["Cookie"] = "" if FastlyCTL::Cookies.length > 0
+        FastlyCTL::Cookies.each do |k,v|
+          headers["Cookie"] << "#{k}=#{v};"
+        end
+      end
+
+      headers["Content-Type"] = "application/x-www-form-urlencoded" if (method == :post || method == :put)
+
+      headers.merge!(options[:headers]) if options[:headers].count > 0
+
+      # dont allow header splitting on anything
+      headers.each do |k,v|
+        headers[k] = v.gsub(/\r|\n/,'')
+      end
+
+      url = "#{options[:endpoint] == :api ? FastlyCTL::FASTLY_API : FastlyCTL::FASTLY_APP}#{path}"
+
+      response = Typhoeus::Request.new(
+        url,
+        method: method,
+        params: options[:params],
+        headers: headers,
+        body: options[:body]
+      ).run
+
+      if options[:expected_responses].include?(response.response_code)
+        if response.headers["Set-Cookie"]
+          response.headers["Set-Cookie"] = [response.headers["Set-Cookie"]] if response.headers["Set-Cookie"].is_a? String
+          response.headers["Set-Cookie"].each do |c|
+            name, value = c.match(/^([^=]*)=([^;]*).*/i).captures
+            FastlyCTL::Cookies[name] = value
+          end
+        end
+      else
+        case response.response_code
+          when 400
+            error = "400: Bad API request--got bad request response."
+          when 403
+            error = "403: Access Denied by API. Run login command to authenticate."
+          when 404
+            error = "404: Service does not exist or bad path requested."
+          when 503
+            error = "503: API is offline."
+          else
+            error = "API responded with status #{response.response_code}."
+        end
+
+        error += " Method: #{method.to_s.upcase}, Path: #{path}\n"
+        error += "Message from API: #{response.response_body}"
+
+        abort error
+      end
+
+      return response.response_body if (response.headers["Content-Type"] != "application/json")
+
+      if response.response_body.length > 1
+        begin
+          return JSON.parse(response.response_body)
+        rescue JSON::ParserError
+          abort "Failed to parse JSON response from Fastly API"
+        end
+      else
+        return {}
+      end
+    end
+
+    def self.domain_to_service_id(domain)
+      response = Typhoeus::Request.new(FastlyCTL::FASTLY_APP, method:"FASTLYSERVICEMATCH", headers: { :host => domain}).run
+
+      abort "Failed to fetch Fastly service ID or service ID does not exist" if response.response_code != 204
+
+      abort "Fastly response did not contain service ID" unless response.headers["Fastly-Service-Id"]
+
+      return response.headers["Fastly-Service-Id"]
+    end
+
+    def self.get_active_version(id)
+      service = self.api_request(:get, "/service/#{id}")
+
+      max = 1
+
+      service["versions"].each do |v|
+        if v["active"] == true
+          return v["number"]
+        end
+
+        max = v["number"] if v["number"] > max
+      end
+
+      return max
+    end
+
+    def self.get_writable_version(id)
+      service = self.api_request(:get, "/service/#{id}")
+
+      active = false
+      version = false
+      max = 1
+      service["versions"].each do |v|
+        if v["active"] == true
+          active = v["number"].to_i
+        end
+
+        if active && v["number"].to_i > active && v["locked"] == false
+          version = v["number"]
+        end
+
+        max = version if version && version > max
+      end
+
+      return max unless active
+
+      version = self.api_request(:put, "/service/#{id}/version/#{active}/clone")["number"] unless version
+
+      return version
+    end
+
+    def self.get_vcl(id, version, generated=false)
+      if generated
+        vcl = self.api_request(:get, "/service/#{id}/version/#{version}/generated_vcl")
+      else
+        vcl = self.api_request(:get, "/service/#{id}/version/#{version}/vcl?include_content=1")
+      end
+
+      if vcl.length == 0
+        return false
+      else
+        return vcl
+      end
+    end
+
+    def self.get_snippets(id,version)
+      snippet = self.api_request(:get, "/service/#{id}/version/#{version}/snippet")
+
+      if snippet.length == 0
+        return false
+      else
+        return snippet
+      end
+    end
+
+    def self.upload_snippet(service,version,content,name)
+      return FastlyCTL::Fetcher.api_request(:put, "/service/#{service}/version/#{version}/snippet/#{name}", {:endpoint => :api, body: {
+          content: content
+        }
+      })
+    end
+
+    def self.upload_vcl(service,version,content,name,is_main=true,is_new=false)
+      params = { name: name, main: "#{is_main ? "1" : "0"}", content: content }
+
+      # try to create, if that fails, update
+      if is_new
+        response = FastlyCTL::Fetcher.api_request(:post, "/service/#{service}/version/#{version}/vcl", {:endpoint => :api, body: params, expected_responses:[200,409]})
+        if response["msg"] != "Duplicate record"
+          return
+        end
+      end
+
+      response = FastlyCTL::Fetcher.api_request(:put, "/service/#{service}/version/#{version}/vcl/#{name}", {:endpoint => :api, body: params, expected_responses: [200,404]})
+
+      # The VCL got deleted so recreate it.
+      if response["msg"] == "Record not found"
+        FastlyCTL::Fetcher.api_request(:post, "/service/#{service}/version/#{version}/vcl", {:endpoint => :api, body: params})
+      end
+    end
+
+    def self.login
+      thor = Thor::Shell::Basic.new
+
+      user = thor.ask("Username: ")
+      pass = thor.ask("Password: ", :echo => false)
+
+      resp = FastlyCTL::Fetcher.api_request(:post, "/login", { :endpoint => :app, params: { user: user, password: pass}})
+
+      if resp["needs_two_factor_auth"]
+        two_factor = true
+
+        thor.say("\nTwo factor auth enabled on account, second factor needed.")
+        code = thor.ask('Please enter verification code:', echo: false)
+
+        resp = FastlyCTL::Fetcher.api_request(:post, "/two_factor_auth/verify", {force_session: true, :endpoint => :app, params: { token: code }} )
+      else
+        thor.say("\nTwo factor auth is NOT enabled. You should go do that immediately.")
+      end
+
+      thor.say("Login successful!")
+
+      return { user: user, pass: pass, two_factor: two_factor, code: code }
+    end
+
+    def self.create_token(options)
+      thor = Thor::Shell::Basic.new
+
+      headers = {}
+      headers["Fastly-OTP"] = options[:code] if options[:code]
+
+      FastlyCTL::Fetcher.api_request(:post, "/sudo", {
+        force_session: true,
+        endpoint: :api,
+        params: {
+          user: options[:user],
+          password: options[:pass]
+        },
+        headers: headers
+      })
+
+      params = {
+          name: options[:name],
+          scope: options[:scope],
+          user: options[:user],
+          password: options[:pass]
+      }
+
+      params[:services] = options[:services] if options[:services]
+
+      resp = FastlyCTL::Fetcher.api_request(:post, "/tokens", {
+        force_session: true,
+        endpoint: :api,
+        params: params,
+        headers: headers
+      })
+
+      thor.say("\n#{resp["id"]} created.")
+
+      return resp
+    end
+  end
+end

data/lib/fastlyctl/utils.rb

@@ -0,0 +1,72 @@
+module FastlyCTL
+  module Utils
+    def self.open_service(id)
+      Launchy.open(FastlyCTL::FASTLY_APP + FastlyCTL::TANGO_PATH + id)
+    end
+
+    def self.parse_directory(path=false)
+      directory = Dir.pwd unless path
+      directory = path if path
+
+      id = directory.match(/.* \- ([^\-]*)$/i)
+      id = id == nil ? false : id.captures[0]
+
+      return id
+    end
+
+    def self.parse_name(path=false)
+      directory = Dir.pwd unless path
+      directory = path if path
+
+      name = directory.match(/(.*) \- [^\-]*$/i)
+      name = name == nil ? false : name.captures[0]
+
+      return name
+    end
+
+    def self.get_diff(old_vcl,new_vcl)
+      options = {
+        include_diff_info: true, 
+        diff: ["-E", "-p"],
+        context: 3
+      }
+      return Diffy::Diff.new(old_vcl, new_vcl, options).to_s(:color)
+    end
+
+    def self.diff_generated(v1,v2)
+      diff = ""
+
+      diff << "\n" + self.get_diff(v1["content"], v2["content"])
+
+      return diff
+    end
+
+    def self.diff_versions(v1,v2)
+      diff = ""
+      v1 ||= Array.new
+      v2 ||= Array.new
+
+      v1.each do |vcl1|
+        v2_content = false
+
+        v2.each do |vcl2|
+          v2_content = vcl2["content"] if (vcl1["name"] == vcl2["name"])
+          if (v2_content)
+            vcl2["matched"] = true
+            break
+          end
+        end
+
+        v2_content = "" unless v2_content
+
+        diff << "\n" + self.get_diff(vcl1["content"], v2_content)
+      end
+
+      v2.each do |vcl|
+        diff << "\n" +  self.get_diff("", vcl["content"]) if !(vcl.has_key? "matched")
+      end
+
+      return diff
+    end
+  end
+end

data/lib/fastlyctl/version.rb

@@ -0,0 +1,3 @@
+module FastlyCTL
+  VERSION = "1.0.1"
+end