vmc 0.0.8 → 0.2.4

data/lib/parse.rb

@@ -1,719 +0,0 @@
-# Copyright 2010, VMware, Inc. Licensed under the
-# MIT license, please see the LICENSE file.  All rights reserved
-
-require File.join(File.dirname(__FILE__),'vmc')
-
-require 'yaml'
-
-def display(msg, nl=true)
-  if nl
-    puts(msg)
-  else
-    print(msg)
-    STDOUT.flush
-  end
-end
-
-def display_usage(msg, nl=true)
-  display("\nUsage: vmc #{msg}\n\n", nl)
-end
-
-def show_help
-  help = %Q{
-
-version                                         # version
-help, -h                                        # show usage
-
-aliases                                         # lists current aliases
-alias               <alias>[=]<command>         # create an alias for a command
-
-target              [host[:port]]               # reports current target or sets the target site
-info                                            # information
-register            [--email, --passwd]         # register and create an account
-login               [email] [--email, --passwd] # login
-logout                                          # logout
-passwd                                          # change password for current user
-user                                            # display current user
-
-services                                        # list of services available
-
-create-service  <service> [--name, --bind]      # create a service instance. we will
-                                                # auto-generate a name if you leave off
-                                                # the --name flag, if you add the --bind
-                                                # flag with an app name we will also bind
-                                                # the service to that app
-
-delete-service   [service]                      # delete the service
-
-bind-service     <service> <appname>            # bind service to appname
-unbind-service   <service> <appname>            # unbind service from appname
-
-apps                                            # list your apps
-push             <appname> [--instances --exec
-                            --noframework --url
-                            --mem --path
-                            --no-start]         # push and start the application
-push             <appname>                      # push and start the application
-start            <appname>                      # start the application
-stop             <appname>                      # stop the application
-restart          <appname>                      # restart the application
-delete           <appname || --all> [--force]   # delete the application
-update           <appname> [--canary]           # update the application
-instances        <appname> [num]                # list instances, scale up or down
-                                                # the number of instances
-
-mem              <appname> [memsize]            # update the memory reservation for this application
-
-crashes          <appname>                      # list recent application crashes
-crashlogs        <appname> [--instance]         # dump all the logs for the crashed instance
-logs             <appname> [--instance]         # dump all the logs for the instance
-files            <appname> [path] [--instance]  # directory listing or file download
-stats            <appname>                      # report resource usage for the application
-
-map              <appname> <url>                # register the application with the url
-unmap            <appname> <url>                # unregister the application from the url
-
-    }
-
-    display(help)
-end
-
-def setup(verb)
-  trap("TERM") { print "\nInterupted\n\n"; exit}
-  trap("INT")  { print "\nInterupted\n\n"; exit}
-  cli = VMC::Client.new
-  cli.set_puser($puser)
-  cli.setup_target_uris
-  # Check to make sure the server is there..
-  cli.check_target unless verb =~ /target/i
-  cli
-end
-
-def get_option(options, default=true)
-  test = [options]
-  args = ARGV
-  return unless opt_index = ARGV.select { |a| test.include? a }.first
-  opt_position = args.index(opt_index) + 1
-  if ARGV.size > opt_position && opt_value = ARGV[opt_position]
-    if opt_value.include?('--')
-      opt_value = nil
-    else
-      ARGV.delete_at(opt_position)
-    end
-  end
-  ARGV.delete(opt_index)
-  opt_value ||= default
-end
-
-$puser = get_option('-u')
-
-# parse command line aliases from '~/.vmc-aliases'
-alias_file = File.expand_path('~/.vmc-aliases')
-if File.exist?(alias_file)
-  aliases = YAML.load_file(alias_file)
-  if key = aliases.values.grep(ARGV[0]).first
-    #display "[#{ARGV[0]} aliased to #{aliases.invert[key]}]"
-    ARGV[0] = aliases.invert[key]
-  end
-end
-
-require 'main'
-
-
-# hack, allows support negative deltas for instances, like vmc instances foo -2
-if ARGV[0] =~ /instances/i && ARGV[2] =~ /(-\d+)/
-  ARGV[2] = '--n'
-  ARGV[3] = $1
-end
-
-Main {
-
-  description "VMware Cloud Command Line Tool"
-
-  mode(:version) {
-    description "Show version of this CLI"
-    def run
-      cli = setup(:version)
-      cli.version
-    end
-  }
-
-  mode(:delete) {
-    description "delete the application"
-    option 'delete-option'
-    argument(:appname){
-      optional
-
-    }
-    option('all'){
-      cast :boolean
-    }
-
-    option('force'){
-      cast :boolean
-    }
-    def run
-      if (! params['all'].given?) && (! params['appname'].given? )
-        display_usage "delete <appname || --all>"
-        exit 1
-      end
-      cli = setup('delete')
-      cli.delete(params['all'].given? ? '--all' : params['appname'].value, params['force'].given?)
-    end
-  }
-
-  #  vmc alias restart bounce
-  mode(:alias) {
-    description "create an alias for a command in our CLI namespace"
-    argument(:_alias){
-      required
-      error { display_usage "alias <alias>[=]<command>" }
-    }
-    argument(:real){ optional }
-    argument(:real2){ optional }
-
-    def run
-      alias_file = File.expand_path('~/.vmc-aliases')
-      aliases = YAML.load_file(alias_file) rescue {}
-
-      _alias = params['_alias'].value
-      real   = params['real'].value
-      real2  = params['real2'].value
-
-      k = v = nil
-
-      if (_alias and real and not real2)
-        k,v = _alias, real
-      elsif (_alias and not real and not real2)
-        k,v = _alias.split('=')
-      elsif (_alias and real and real2 and real == '=')
-        k,v = _alias, real2
-      else
-        display_usage "alias <alias>[=]<command>"
-        exit(1)
-      end
-
-      aliases[v] = k
-      File.open(alias_file, 'wb') {|f| f.write(aliases.to_yaml)}
-      display("Successfully aliased #{k} to #{v}")
-    rescue => e
-      error("There was a problem writing to the '~/.vmc-aliases' file:  #{e}")
-    end
-  }
-
-  mode(:aliases) {
-    description "List aliases"
-
-    def run
-      alias_file = File.expand_path('~/.vmc-aliases')
-      aliases = YAML.load_file(alias_file) rescue {}
-      aliases.each do |k,v|
-        display "#{v} = #{k}"
-      end
-    end
-  }
-
-  mode('remove-alias') {
-    description "Remove alias"
-    argument(:_alias){
-      required
-      error { display_usage "remove-alias <alias>" }
-    }
-
-    def run
-      alias_file = File.expand_path('~/.vmc-aliases')
-      aliases = YAML.load_file(alias_file) rescue {}
-      aliases.each do |k,v|
-        aliases.delete(k) if v == params['_alias'].value
-      end
-      File.open(alias_file, 'wb') {|f| f.write(aliases.to_yaml)}
-      display "Successfully removed alias: #{params['_alias'].value}\nRemaining aliases:\n"
-      aliases.each do |k,v|
-        display "#{v} = #{k}"
-      end
-
-    end
-  }
-
-  mode(:target) {
-    description "Set the target Cloud for this CLI session"
-    argument(:host){ optional }
-    def run
-      cli = setup('target')
-      cli.target(params['host'].value)
-    end
-  }
-
-  mode(:info) {
-    description "information (optionally about services)"
-    def run
-      cli = setup('info')
-      cli.info
-    end
-  }
-
-  mode(:register) {
-    description "register and create an account"
-
-    option('email=[email]'){
-      arity 1
-    }
-
-    option('passwd=[passwd]'){
-      arity 1
-    }
-
-    def run
-      cli = setup('register')
-      cli.register(params['email'].value, params['passwd'].value)
-    end
-  }
-
-  mode(:login) {
-    description "login to the cloud"
-
-    argument(:email_arg) { optional }
-    argument(:passwd_arg) { optional }
-
-
-    option('email=[email]'){
-      arity 1
-    }
-
-    option('passwd=[passwd]'){
-      arity 1
-    }
-
-    def run
-      cli = setup('login')
-
-      email = params['email_arg'].given? ? params['email_arg'].value : params['email'].value
-      pass = params['passwd_arg'].given? ? params['passwd_arg'].value : params['passwd'].value
-      cli.login(email, pass)
-    end
-  }
-
-  mode(:logout) {
-    description "logout"
-    def run
-      cli = setup('logout')
-      cli.logout
-    end
-  }
-
-  mode(:passwd) {
-    description "change password for current user"
-
-    option('passwd=[passwd]'){
-      arity 1
-    }
-
-    def run
-      cli = setup('passwd')
-      cli.passwd(params['passwd'].value)
-    end
-  }
-
-  mode(:user) {
-    description "display current user"
-    def run
-      cli = setup('user')
-      cli.user
-    end
-  }
-
-  mode(:services) {
-    description "list of services available"
-    def run
-      cli = setup('services')
-      cli.services
-    end
-  }
-
-
-  # vmc create-service redis --name my-redis
-  mode('create-service') {
-    description "provision a service"
-    option 'add-option'
-
-    argument(:servicename) {
-      required
-      error { display_usage "create-service <service> [--name, --bind]" }
-    }
-
-    argument(:pname) { optional }
-    argument(:pbind) { optional }
-
-    option('name=[name]'){
-      arity 1
-    }
-
-    option('bind=[bind]'){
-      arity 1
-    }
-
-    def run
-      cli = setup('create_service')
-      opts = {
-        :bind => params['bind'].value || params['pbind'].value,
-        :name => params['name'].value || params['pname'].value,
-      }
-      cli.create_service(params['servicename'].value, opts)
-    end
-  }
-
-  mode('delete-service') {
-    description "Delete a provisioned service"
-    argument(:servicename) { optional }
-
-    def run
-      cli = setup('delete_service')
-      cli.delete_service(params['servicename'].value)
-    end
-  }
-
-  mode('bind-service') {
-    description "Bind a provisioned service"
-
-    argument(:servicename){
-      required
-      error { display_usage "bind-service <service> <appname>" }
-    }
-    argument(:appname){
-      required
-      error { display_usage "bind-service <service> <appname>" }
-    }
-
-    def run
-      cli = setup('bind_service')
-      cli.bind_service(params['servicename'].value, params['appname'].value)
-    end
-  }
-
-  mode('unbind-service') {
-    description "Bind a provisioned service"
-
-    argument(:servicename){
-      required
-      error { display_usage "unbind-service <service> <appname>" }
-    }
-    argument(:appname){
-      required
-      error { display_usage "unbind-service <service> <appname>" }
-    }
-
-    def run
-      cli = setup('unbind_service')
-      cli.unbind_service(params['servicename'].value, params['appname'].value)
-    end
-  }
-
-  mode(:apps) {
-    description "list your apps"
-    option 'apps-option'
-
-    def run
-      cli = setup('apps')
-      cli.apps(nil)
-    end
-  }
-
-  mode(:mem) {
-    argument(:appname){
-      required
-      error { display_usage "mem <appname> [memsize]"}
-    }
-    argument(:memsize){ optional }
-    def run
-      if params['memsize'].given?
-        unless %w(64M 128M 256M 512M 1G 2G).include?(params['memsize'].value)
-          display_usage "mem <appname> <memsize>"
-          display "<memsize> must be one of: (64M 128M 256M 512M)"
-          display "you provided #{params['memsize'].value}"
-          exit 1
-        end
-      end
-
-      cli = setup('mem')
-      cli.mem(params['appname'].value, params['memsize'].value)
-    end
-
-  }
-
-  mode(:push) {
-    description "push and start the application"
-    option 'push-option'
-    argument(:appname){ optional }
-
-    option('instances=[instances]'){
-      arity 1
-    }
-
-    option('exec=[exec]'){
-      arity 1
-    }
-
-    option('path=[path]'){
-      arity 1
-    }
-
-    option('noframework'){
-      default false
-    }
-
-    option('url=[url]'){
-      arity 1
-    }
-
-    option('mem=[mem]'){
-      arity 1
-    }
-
-    option('no-start'){
-
-    }
-
-    def run
-      cli = setup('push')
-
-      if params['mem'].given?
-        unless %w(64M 128M 256M 512M 1G 2G).include?(params['mem'].value)
-          display_usage "push --mem <memsize>"
-          display "<memsize> must be one of: (64M 128M 256M 512M)"
-          display "you provided #{params['mem'].value}"
-          exit 1
-        end
-      end
-
-      opts = {:instances => params['instances'].value,
-              :exec => params['exec'].value,
-              :noframework => params['noframework'].value,
-              :appname => params['appname'].value,
-              :url => params['url'].value,
-              :mem => params['mem'].value,
-              :path => params['path'].value,
-              :no_start => params['no-start'].given?
-              }
-      cli.push(opts)
-    end
-  }
-
-  mode(:start) {
-    description "start the application"
-    option 'start-option'
-    argument(:appname){
-      required
-      error { display_usage "start <appname>" }
-    }
-    def run
-      cli = setup('start')
-      cli.start(params['appname'].value)
-    end
-  }
-
-  mode(:stop) {
-    description "stop the application"
-    option 'stop-option'
-    argument(:appname){
-      required
-      error { display_usage "stop <appname>" }
-    }
-    def run
-      cli = setup('stop')
-      cli.stop(params['appname'].value)
-    end
-  }
-
-  mode(:restart) {
-    description "restart the application"
-    option 'restart-option'
-    argument(:appname){
-      required
-      error { display_usage "restart <appname>" }
-    }
-    def run
-      cli = setup('restart')
-      cli.restart(params['appname'].value)
-    end
-  }
-
-  mode(:update) {
-    description "update the application"
-    option 'update-option'
-    argument(:appname){
-      required
-      error { display_usage "update <appname> [--canary]" }
-    }
-    option('canary'){
-      cast :bool
-      default true
-      optional
-    }
-    def run
-      cli = setup('update')
-      cli.update(params['appname'].value, params['canary'].given?)
-    end
-  }
-
-  mode(:instances) {
-    description "list instances, scale up or down the number of instances"
-    option 'instances-option'
-
-    argument(:appname){
-      required
-      error { display_usage "instances <appname> [num]" }
-    }
-    argument(:num){
-      optional
-    }
-    option(:n) {
-      argument_required
-    }
-
-    def run
-      cli = setup('instances')
-      chg = params['n'].given? ? params['n'].value : params['num'].value
-      cli.instances(params['appname'].value, chg)
-    end
-  }
-
-  mode(:map) {
-    description "register the application with the url"
-    option 'map-option'
-    argument(:appname){
-      required
-      error { display_usage "map <appname> <url>"}
-    }
-    argument(:url){
-      required
-      error { display_usage "map <appname> <url>"}
-    }
-
-    def run
-      cli = setup('map')
-      cli.map(params['appname'].value, params['url'].value)
-    end
-  }
-
-  mode(:unmap) {
-    description "unregister the application from the url"
-    option 'unmap-option'
-    argument(:appname){
-      required
-      error { display_usage "unmap <appname> <url>"}
-    }
-    argument(:url){
-      required
-      error { display_usage "unmap <appname> <url>"}
-    }
-    def run
-      cli = setup('unmap')
-      cli.unmap(params['appname'].value, params['url'].value)
-    end
-  }
-
-  mode(:crashes) {
-    description "list recent application crashes"
-    option 'crashes-option'
-    argument(:appname){
-      required
-      error { display_usage "crashes <appname>" }
-    }
-    def run
-      cli = setup('crashes')
-      cli.crashes(params['appname'].value)
-    end
-  }
-
-  mode(:files) {
-    description "directory listing or file download"
-    option 'files-option'
-    argument(:appname){
-      required
-      error { display_usage "files <appname> [path]" }
-    }
-    argument(:dir_or_file){ optional }
-    option('instance', 'i'){
-      default '0'
-      optional
-      arity 1
-      argument_required
-    }
-    def run
-      cli = setup('files')
-      cli.files(params['appname'].value, params['dir_or_file'].value, params['instance'].value)
-    end
-  }
-
-  mode(:crashlogs) {
-    description "Dump all logs from first crashed instance"
-    argument(:appname){
-      required
-      error { display_usage "crashlogs <appname> [--instance]" }
-    }
-    option('instance', 'i'){
-      default '0'
-      arity 1
-      optional
-      argument_required
-    }
-
-    def run
-      cli = setup('crashlogs')
-      cli.grab_crash_logs(params['appname'].value, params['instance'].value)
-    end
-  }
-
-  mode(:logs) {
-    description "Dump all logs"
-    argument(:appname){
-      required
-      error { display_usage "logs <appname> [--instance]" }
-    }
-    option('instance', 'i'){
-      default '0'
-      arity 1
-      optional
-      argument_required
-    }
-
-    def run
-      cli = setup('logs')
-      cli.grab_logs(params['appname'].value,  params['instance'].value)
-    end
-  }
-
-  mode(:stats) {
-    description "report resource usage for the application"
-    option 'stats-option'
-    argument(:appname){
-      required
-      error { display_usage "stats <appname>" }
-    }
-    def run
-      cli = setup('stats')
-      cli.stats(params['appname'].value)
-    end
-  }
-
-  mode(:help) {
-    show_help
-  }
-
-  mode('-h') {
-    show_help
-  }
-
-  mode('-v') {
-    description "Show version of this CLI"
-    def run
-      cli = setup(:version)
-      cli.version
-    end
-  }
-
-  def run
-    display "\nUsage: vmc COMMAND [OPTIONS] 'vmc -h' for more information.\n\n"
-  end
-
-}