cf 0.1.0

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c)2012, Alex Suraci
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Alex Suraci nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/cf

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# vim: ft=ruby
+
+require "rubygems"
+require "thor"
+
+require "cf"
+require "cf/plugin"
+
+CF::Plugin.load_all
+
+$exit_status = 0
+CF::CLI.start(ARGV)
+exit($exit_status)

data/lib/cf.rb

@@ -0,0 +1,2 @@
+require "cf/version"
+require "cf/cli"

data/lib/cf/cli.rb

@@ -0,0 +1,249 @@
+require "cf/cli/command"
+require "cf/cli/app"
+require "cf/cli/service"
+require "cf/cli/user"
+
+module CF
+  class CLI < App # subclass App since we operate on Apps by default
+    class_option :verbose,
+      :type => :boolean, :aliases => "-v", :desc => "Verbose"
+
+    class_option :force,
+      :type => :boolean, :aliases => "-f", :desc => "Force (no interaction)"
+
+    class_option :simple_output,
+      :type => :boolean, :desc => "Simplified output format."
+
+    class_option :script, :type => :boolean, :aliases => "-s",
+      :desc => "--simple-output and --force"
+
+    class_option :color, :type => :boolean, :desc => "Colored output"
+
+    desc "service SUBCOMMAND ...ARGS", "Manage your services"
+    subcommand "service", Service
+
+    desc "user SUBCOMMAND ...ARGS", "User management"
+    subcommand "user", User
+
+    desc "info", "Display information on the current target, user, et."
+    flag(:runtimes)
+    flag(:services)
+    def info
+      info =
+        with_progress("Getting target information") do
+          client.info
+        end
+
+      if input(:runtimes)
+        runtimes = {}
+        info["frameworks"].each do |_, f|
+          f["runtimes"].each do |r|
+            runtimes[r["name"]] = r
+          end
+        end
+
+        runtimes = runtimes.values.sort_by { |x| x["name"] }
+
+        if simple_output?
+          runtimes.each do |r|
+            puts r["name"]
+          end
+          return
+        end
+
+        runtimes.each do |r|
+          puts ""
+          puts "#{c(r["name"], :blue)}:"
+          puts "  version: #{b(r["version"])}"
+          puts "  description: #{b(r["description"])}"
+        end
+
+        return
+      end
+
+      if input(:services)
+        services = {}
+        client.system_services.each do |_, svcs|
+          svcs.each do |name, versions|
+            services[name] = versions.values
+          end
+        end
+
+        if simple_output?
+          services.each do |name, _|
+            puts name
+          end
+
+          return
+        end
+
+        services.each do |name, versions|
+          puts ""
+          puts "#{c(name, :blue)}:"
+          puts "  versions: #{versions.collect { |v| v["version"] }.join ", "}"
+          puts "  description: #{versions[0]["description"]}"
+          puts "  type: #{versions[0]["type"]}"
+        end
+
+        return
+      end
+
+      puts ""
+
+      puts info["description"]
+      puts ""
+      puts "target: #{b(client.target)}"
+      puts "  version: #{info["version"]}"
+      puts "  support: #{info["support"]}"
+      puts ""
+      puts "user: #{b(info["user"])}"
+      puts "  usage:"
+
+      limits = info["limits"]
+      info["usage"].each do |k, v|
+        m = limits[k]
+        if k == "memory"
+          puts "    #{k}: #{usage(v * 1024 * 1024, m * 1024 * 1024)}"
+        else
+          puts "    #{k}: #{b(v)} of #{b(m)} limit"
+        end
+      end
+    end
+
+    desc "target URL", "Set target cloud"
+    def target(url)
+      target = sane_target_url(url)
+      display = c(target.sub(/https?:\/\//, ""), :blue)
+      with_progress("Setting target to #{display}") do
+        unless force?
+          # check that the target is valid
+          Conduit::Client.new(target).info
+        end
+
+        set_target(target)
+      end
+    end
+
+    desc "login [EMAIL]", "Authenticate with the target"
+    flag(:email) {
+      ask("Email")
+    }
+    flag(:password)
+    # TODO: implement new authentication scheme
+    def login(email = nil)
+      unless simple_output?
+        puts "Target: #{c(client_target, :blue)}"
+        puts ""
+      end
+
+      email ||= input(:email)
+      password = input(:password)
+
+      authenticated = false
+      failed = false
+      until authenticated
+        unless force?
+          if failed || !password
+            password = ask("Password", :echo => "*", :forget => true)
+          end
+        end
+
+        with_progress("Authenticating") do |s|
+          begin
+            save_token(client.login(email, password))
+            authenticated = true
+          rescue Conduit::Denied
+            return if force?
+
+            s.fail do
+              failed = true
+            end
+          end
+        end
+      end
+    ensure
+      $exit_status = 1 if not authenticated
+    end
+
+    desc "logout", "Log out from the target"
+    def logout
+      with_progress("Logging out") do
+        remove_token
+      end
+    end
+
+    desc "register [EMAIL]", "Create a user and log in"
+    flag(:email) {
+      ask("Email")
+    }
+    flag(:password) {
+      ask("Password", :echo => "*", :forget => true)
+    }
+    flag(:no_login, :type => :boolean)
+    def register(email = nil)
+      unless simple_output?
+        puts "Target: #{c(client_target, :blue)}"
+        puts ""
+      end
+
+      email ||= input(:email)
+      password = input(:password)
+
+      with_progress("Creating user") do
+        client.register(email, password)
+      end
+
+      unless input(:skip_login)
+        with_progress("Logging in") do
+          save_token(client.login(email, password))
+        end
+      end
+    end
+
+    desc "services", "List your services"
+    def services
+      services =
+        with_progress("Getting services") do
+          client.services
+        end
+
+      puts "" unless simple_output?
+
+      services.each do |s|
+        display_service(s)
+      end
+    end
+
+    desc "users", "List all users"
+    def users
+      users =
+        with_progress("Getting users") do
+          client.users
+        end
+
+      users.each do |u|
+        display_user(u)
+      end
+    end
+
+    private
+
+    def display_service(s)
+      if simple_output?
+        puts s.name
+      else
+        puts "#{c(s.name, :blue)}: #{s.vendor} v#{s.version}"
+      end
+    end
+
+    def display_user(u)
+      if simple_output?
+        puts u.email
+      else
+        puts ""
+        puts "#{c(u.email, :blue)}:"
+        puts "  admin?: #{c(u.admin?, u.admin? ? :green : :red)}"
+      end
+    end
+  end
+end

data/lib/cf/cli/app.rb

@@ -0,0 +1,545 @@
+require "cf/cli/command"
+require "cf/detect"
+
+module CF
+  class App < Command
+    MEM_CHOICES = ["64M", "128M", "256M", "512M"]
+
+    desc "apps", "List your applications"
+    def apps
+      apps =
+        with_progress("Getting applications") do
+          client.apps
+        end
+
+      apps.each.with_index do |a, num|
+        display_app(a)
+      end
+    end
+
+    desc "stop [APP]", "Stop an application"
+    def stop(name)
+      with_progress("Stopping #{c(name, :blue)}") do |s|
+        app = client.app(name)
+
+        unless app.exists?
+          s.fail do
+            err "Unknown application."
+          end
+        end
+
+        if app.stopped?
+          s.skip do
+            err "Application is not running."
+          end
+        end
+
+        app.stop!
+      end
+    end
+
+    desc "start [APP]", "Start an application"
+    flag(:debug_mode)
+    def start(name)
+      app = client.app(name)
+
+      unless app.exists?
+        err "Unknown application."
+        return
+      end
+
+      switch_mode(app, input(:debug_mode))
+
+      with_progress("Starting #{c(name, :blue)}") do |s|
+        if app.running?
+          s.skip do
+            err "Already started."
+            return
+          end
+        end
+
+        app.start!
+      end
+
+      check_application(app)
+
+      if app.debug_mode && !simple_output?
+        puts ""
+        instances(name)
+      end
+    end
+
+    desc "restart [APP]", "Stop and start an application"
+    flag(:debug_mode)
+    def restart(name)
+      stop(name)
+      start(name)
+    end
+
+    desc "delete [APP]", "Delete an application"
+    flag(:really) { |name|
+      force? || ask("Really delete #{c(name, :blue)}?", :default => false)
+    }
+    def delete(name)
+      return unless input(:really, name)
+
+      with_progress("Deleting #{c(name, :blue)}") do
+        client.app(name).delete!
+      end
+    ensure
+      forget(:really)
+    end
+
+    desc "instances [APP]", "List an app's instances"
+    def instances(name)
+      instances =
+        with_progress("Getting instances for #{c(name, :blue)}") do
+          client.app(name).instances
+        end
+
+      instances.each do |i|
+        if simple_output?
+          puts i.index
+        else
+          puts ""
+          display_instance(i)
+        end
+      end
+    end
+
+    desc "files [APP] [PATH]", "Examine an app's files"
+    def files(name, path = "/")
+      files =
+        with_progress("Getting file listing") do
+          client.app(name).files(*path.split("/"))
+        end
+
+      puts "" unless simple_output?
+
+      files.each do |file|
+        puts file
+      end
+    end
+
+    desc "file [APP] [PATH]", "Print out an app's file contents"
+    def file(name, path = "/")
+      file =
+        with_progress("Getting file contents") do
+          client.app(name).file(*path.split("/"))
+        end
+
+      puts "" unless simple_output?
+
+      print file
+    end
+
+    desc "logs [APP]", "Print out an app's logs"
+    flag(:instance, :type => :numeric, :default => 0)
+    def logs(name)
+      app = client.app(name)
+      unless app.exists?
+        err "Unknown application."
+        return
+      end
+
+      instances =
+        if input(:instance) == "all"
+          app.instances
+        else
+          app.instances.select { |i| i.index == input(:instance) }
+        end
+
+      if instances.empty?
+        if input(:instance) == "all"
+          err "No instances found."
+        else
+          err "Instance #{name} \##{input(:instance)} not found."
+        end
+
+        return
+      end
+
+      instances.each do |i|
+        logs =
+          with_progress(
+            "Getting logs for " +
+              c(name, :blue) + " " +
+              c("\##{i.index}", :yellow)) do
+            i.files("logs")
+          end
+
+        puts "" unless simple_output?
+
+        logs.each do |log|
+          body =
+            with_progress("Reading " + b(log.join("/"))) do
+              i.file(*log)
+            end
+
+          puts body
+          puts "" unless body.empty?
+        end
+      end
+    end
+
+    desc "push [NAME]", "Push an application, syncing changes if it exists"
+    flag(:name) { ask("Name") }
+    flag(:path) {
+      ask("Push from...", :default => ".")
+    }
+    flag(:url) { |name, target|
+      ask("URL", :default => "#{name}.#{target}")
+    }
+    flag(:memory) {
+      ask("Memory Limit",
+          :choices => MEM_CHOICES,
+
+          # TODO: base this on framework choice
+          :default => "64M")
+    }
+    flag(:instances) {
+      ask("Instances", :default => 1)
+    }
+    flag(:framework) { |choices, default|
+      ask("Framework", :choices => choices, :default => default)
+    }
+    flag(:runtime) { |choices|
+      ask("Runtime", :choices => choices)
+    }
+    flag(:start, :default => true)
+    flag(:restart, :default => true)
+    def push(name = nil)
+      path = File.expand_path(input(:path))
+
+      name ||= input(:name)
+
+      detector = Detector.new(client, path)
+      frameworks = detector.all_frameworks
+      detected, default = detector.frameworks
+
+      app = client.app(name)
+
+      if app.exists?
+        upload_app(app, path)
+        restart(app.name) if input(:restart)
+        return
+      end
+
+      app.total_instances = input(:instances)
+
+      domain = client.target.sub(/^https?:\/\/api\.(.+)\/?/, '\1')
+      app.urls = [input(:url, name, domain)]
+
+      framework = input(:framework, ["other"] + detected.keys, default)
+      if framework == "other"
+        forget(:framework)
+        framework = input(:framework, frameworks.keys)
+      end
+
+      framework_runtimes =
+        frameworks[framework]["runtimes"].collect do |k|
+          "#{k["name"]} (#{k["description"]})"
+        end
+
+      # TODO: include descriptions
+      runtime = input(:runtime, framework_runtimes).split.first
+
+      app.framework = framework
+      app.runtime = runtime
+
+      app.memory = megabytes(input(:memory))
+
+      with_progress("Creating #{c(name, :blue)}") do
+        app.create!
+      end
+
+      begin
+        upload_app(app, path)
+      rescue
+        err "Upload failed. Try again with 'vmc push'."
+        raise
+      end
+
+      start(name) if input(:start)
+    end
+
+    desc "update", "DEPRECATED", :hide => true
+    def update(*args)
+      err "The 'update' command is no longer used; use 'push' instead."
+    end
+
+    desc "stats", "Display application instance status"
+    def stats(name)
+      stats =
+        with_progress("Getting stats") do
+          client.app(name).stats
+        end
+
+      stats.sort_by { |k, _| k }.each do |idx, info|
+        stats = info["stats"]
+        usage = stats["usage"]
+        puts ""
+        puts "instance #{c("#" + idx, :blue)}:"
+        print "  cpu: #{percentage(usage["cpu"])} of"
+        puts " #{b(stats["cores"])} cores"
+        puts "  memory: #{usage(usage["mem"] * 1024, stats["mem_quota"])}"
+        puts "  disk: #{usage(usage["disk"], stats["disk_quota"])}"
+      end
+    end
+
+    desc "scale [APP]", "Update the instances/memory limit for an application"
+    flag(:instances, :type => :numeric) { |default|
+      ask("Instances", :default => default)
+    }
+    flag(:memory) { |default|
+      ask("Memory Limit",
+          :default => human_size(default * 1024 * 1024, 0),
+          :choices => MEM_CHOICES)
+    }
+    def scale(name)
+      app = client.app(name)
+
+      instances = passed_value(:instances)
+      memory = passed_value(:memory)
+
+      unless instances || memory
+        instances = input(:instances, app.total_instances)
+        memory = input(:memory, app.memory)
+      end
+
+      with_progress("Scaling #{c(name, :blue)}") do
+        app.total_instances = instances.to_i if instances
+        app.memory = megabytes(memory) if memory
+        app.update!
+      end
+    end
+
+    desc "map NAME URL", "Add a URL mapping for an app"
+    def map(name, url)
+      simple = url.sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+      with_progress("Updating #{c(name, :blue)}") do
+        app = client.app(name)
+        app.urls << simple
+        app.update!
+      end
+    end
+
+    desc "unmap NAME URL", "Remove a URL mapping from an app"
+    def unmap(name, url)
+      simple = url.sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+      with_progress("Updating #{c(name, :blue)}") do |s|
+        app = client.app(name)
+
+        unless app.urls.delete(simple)
+          s.fail do
+            err "URL #{url} is not mapped to this application."
+            return
+          end
+        end
+
+        app.update!
+      end
+    end
+
+    class Env < Command
+      VALID_NAME = /^[a-zA-Za-z_][[:alnum:]_]*$/
+
+      desc "set [APP] [NAME] [VALUE]", "Set an environment variable"
+      def set(appname, name, value)
+        app = client.app(appname)
+        unless name =~ VALID_NAME
+          err "Invalid variable name; must match #{VALID_NAME.inspect}"
+          return
+        end
+
+        unless app.exists?
+          err "Unknown application."
+          return
+        end
+
+        with_progress("Updating #{c(app.name, :blue)}") do
+          app.update!("env" =>
+                        app.env.reject { |v|
+                          v.start_with?("#{name}=")
+                        }.push("#{name}=#{value}"))
+        end
+      end
+
+      desc "unset [APP] [NAME]", "Remove an environment variable"
+      def unset(appname, name)
+        app = client.app(appname)
+
+        unless app.exists?
+          err "Unknown application."
+          return
+        end
+
+        with_progress("Updating #{c(app.name, :blue)}") do
+          app.update!("env" =>
+                        app.env.reject { |v|
+                          v.start_with?("#{name}=")
+                        })
+        end
+      end
+
+      desc "list [APP]", "Show all environment variables set for an app"
+      def list(appname)
+        vars =
+          with_progress("Getting variables") do |s|
+            app = client.app(appname)
+
+            unless app.exists?
+              s.fail do
+                err "Unknown application."
+                return
+              end
+            end
+
+            app.env
+          end
+
+        puts "" unless simple_output?
+
+        vars.each do |pair|
+          name, val = pair.split("=", 2)
+          puts "#{c(name, :blue)}: #{val}"
+        end
+      end
+    end
+
+    desc "env SUBCOMMAND ...ARGS", "Manage application environment variables"
+    subcommand "env", Env
+
+    private
+
+    def upload_app(app, path)
+      with_progress("Uploading #{c(app.name, :blue)}") do
+        app.upload(path)
+      end
+    end
+
+    # set app debug mode, ensuring it's valid, and shutting it down
+    def switch_mode(app, mode)
+      mode = nil if mode == "none"
+
+      return false if app.debug_mode == mode
+
+      if mode.nil?
+        with_progress("Removing debug mode") do
+          app.debug_mode = nil
+          app.stop! if app.running?
+        end
+
+        return true
+      end
+
+      with_progress("Switching mode to #{c(mode, :blue)}") do |s|
+        runtimes = client.system_runtimes
+        modes = runtimes[app.runtime]["debug_modes"] || []
+        if modes.include?(mode)
+          app.debug_mode = mode
+          app.stop! if app.running?
+          true
+        else
+          s.fail do
+            err "Unknown mode '#{mode}'; available: #{modes.inspect}"
+            false
+          end
+        end
+      end
+    end
+
+    APP_CHECK_LIMIT = 60
+
+    def check_application(app)
+      with_progress("Checking #{c(app.name, :blue)}") do |s|
+        if app.debug_mode == "suspend"
+          s.skip do
+            puts "Application is in suspended debugging mode."
+            puts "It will wait for you to attach to it before starting."
+          end
+        end
+
+        seconds = 0
+        until app.healthy?
+          sleep 1
+          seconds += 1
+          if seconds == APP_CHECK_LIMIT
+            s.give_up do
+              err "Application failed to start."
+              # TODO: print logs
+            end
+          end
+        end
+      end
+    end
+
+    # choose the right color for app/instance state
+    def state_color(s)
+      case s
+      when "STARTING"
+        :blue
+      when "STARTED", "RUNNING"
+        :green
+      when "DOWN"
+        :red
+      when "FLAPPING"
+        :magenta
+      when "N/A"
+        :cyan
+      else
+        :yellow
+      end
+    end
+
+    def display_app(a)
+      if simple_output?
+        puts a.name
+        return
+      end
+
+      puts ""
+
+      health = a.health
+
+      if a.debug_mode == "suspend" && health == "0%"
+        status = c("suspended", :yellow)
+      else
+        status = c(health.downcase, state_color(health))
+      end
+
+      print "#{c(a.name, :blue)}: #{status}"
+
+      unless a.total_instances == 1
+        print ", #{b(a.total_instances)} instances"
+      end
+
+      puts ""
+
+      unless a.urls.empty?
+        puts "  urls: #{a.urls.collect { |u| b(u) }.join(", ")}"
+      end
+
+      unless a.services.empty?
+        puts "  services: #{a.services.collect { |s| b(s) }.join(", ")}"
+      end
+    end
+
+    def display_instance(i)
+      print "instance #{c("\##{i.index}", :blue)}: "
+      puts "#{b(c(i.state.downcase, state_color(i.state)))} "
+
+      puts "  started: #{c(i.since.strftime("%F %r"), :cyan)}"
+
+      if d = i.debugger
+        puts "  debugger: port #{c(d["port"], :blue)} at #{c(d["ip"], :blue)}"
+      end
+
+      if c = i.console
+        puts "  console: port #{b(c["port"])} at #{b(c["ip"])}"
+      end
+    end
+  end
+end