mms-api 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f84b83712abb35d5ddc92349e7f7edc6ce8ce1d
-  data.tar.gz: 9402addd71a60272c9c7ec83b615f0dff43807b4
+  metadata.gz: 7f238c7242a72f7afcaf801e4471a6a772377b30
+  data.tar.gz: b7db404c176c296832c46552d104a7adb8abb899
 SHA512:
-  metadata.gz: 0b33d1456eb0dd74586cd4cae98fd2c58f943ce3232a37bf5dbe025c34d907af08cdb78bfa2badf6816bad4a88ddb5958459d658ac87a914e0ebf6cfb45e7e83
-  data.tar.gz: b06c7b7efc6826286ea196834b8e3bd99c3cabb61526283aaa4f68a1e9dba9c4e543290108af2f2b5239205abe6549a7ca9c26aaa9936360a764e95cbe7018b0
+  metadata.gz: b8dca3e5b69c6dc916920e52abffb1d1647f6a59571cbdf0307714564f7a8e43256dbb78ce46bea5d937eca2def867dc92e43d04e2ebd4e3182d2984df680ad8
+  data.tar.gz: 98f2a85f55e5f1cf942dda16d2745955745dee3ff52afbcb60d3c3261aa332e1e978d804eafeb16e99c59fd85098468f1c71b1e0e1dcbe6fd5b6824cf78e4b97

data/README.md

@@ -8,40 +8,6 @@ Installation
 gem install mms-api
 ```
 
-Cli
----
-```bash
-$ mms-api --help
-mms-api is a tool for accessing MMS API
-
-Usage:
-
-	mms-api command [options]
-
-Commands:
-
-	groups | hosts | clusters | snapshots | restorejobs | restorejobs-create
-
-Options:
-
-    -u, --username <string>           MMS user
-    -k, --apikey <string>             MMS api-key
-    -a, --apiurl <string>             MMS api url. Full url including version: https://mms.mydomain.tld/api/public/v1.0
-    -n, --name <string>               Filter by resource name using regexp
-    -l, --limit <int>                 Limit for result items
-    -v, --version                     Version
-    -h, --help                        Show this help
-```
-
-`mms-api` reads default configuration from your home directory `~/.mms-api`. Example configuration:
-
-```
-username=sysadmin@example.tld
-apikey=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-# apiurl=https://mms.mydomain.tld/api/public/v1.0
-# action=hosts
-```
-
 API coverage
 ------------
 The MMS Public API follows the principles of the REST architectural style to expose a number of internal resources which enable programmatic access to [MMS’s features](http://mms.mongodb.com/help/reference/api/). Current implementation support only a few of API features.
@@ -52,39 +18,66 @@ The MMS Public API follows the principles of the REST architectural style to exp
 |Hosts| + | + | | | | |
 |Clusters| + | + | | | | |
 |Snapshots| + | + | | | | |
+|Alerts| + | + | | | | |
 |Restore Jobs| + | + | + | | | |
 
+Config
+------
+```ruby
+config = MMS::Config.new
+```
+
+Client
+------
+```ruby
+client = MMS::Client.new(config.username, config.apikey)
+```
 
-Example
--------
+Agent
+-----
 ```ruby
-require 'mms'
+agent = MMS::Agent.new(client)
+```
 
-agent = MMS::Agent.new('username', 'apikey')
+Cli
+---
+```bash
+$ mms-api --help
+Usage:
+     [OPTIONS] SUBCOMMAND [ARG] ...
 
-# all available resources
-group_list = agent.groups
-host_list = agent.hosts
-cluster_list = agent.clusters
-snapshot_list = agent.snapshots
-job_list = agent.restorejobs
+Parameters:
+    SUBCOMMAND                    subcommand
+    [ARG] ...                     subcommand arguments
 
-# get first cluster from list
-cluster = cluster_list.first
+Subcommands:
+    groups                        Groups
+    hosts                         Hosts
+    clusters                      Clusters
+    alerts                        Alerts
+    snapshots                     Snapshots
+    restorejobs                   Restorejobs
 
-# get list of all restore-jobs for specific cluster
-job_list = agent.findGroup(cluster.group.id).cluster(cluster.id).restorejobs
-# or simply using cluster instance
-job_list = cluster.restorejobs
+Options:
+    -h, --help                    print help
+    -u, --username <string>       MMS user
+    -k, --apikey <string>         MMS api-key
+    -a, --apiurl <string>         MMS api url. Full url including version: https://mms.mydomain.tld/api/public/v1.0
+    -v, --version                 Version
+    -g, --default-group-id <string> Default MMS group id
+    -c, --default-cluster-id <string> Default MMS cluster id
+    --cfg <string>                Config file path
+    -i, --ignore                  Ignore flag of --group-id and -cluster-id (default: false)
+    -j, --json                    Print JSON output (default: false)
+    -l, --limit <integer>         Limit for result items
+```
 
-# get first snapshot from list
-snapshot = snapshot_list.first
+`mms-api` reads default configuration from your home directory `~/.mms-api`. Example configuration:
 
-# create restore job for snapshot
-group_id = snapshot.cluster.group.id
-cluster_id = snapshot.cluster.id
-snapshot_id = snapshot.id
-job_list = agent.findGroup(group_id).cluster(cluster_id).snapshot(snapshot_id).create_restorejob
-# or simply using snapshot instance
-job_list = snapshot.create_restorejob
+```
+username=sysadmin@example.tld
+apikey=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+# apiurl=https://mms.mydomain.tld/api/public/v1.0
+default_group_id=your-group-id
+default_cluster_id=your-cluster-id
 ```

data/bin/mms-api

@@ -1,151 +1,6 @@
 #!/usr/bin/env ruby
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
-
 require 'mms'
-require 'optparse'
-require 'terminal-table'
-require 'parseconfig'
-require 'pathname'
-
-actions_available = ["groups", "hosts", "clusters", "snapshots", "restorejobs", "restorejobs-create"]
-
-app_name = 'mms-api'
-app_dscr = "#{app_name} is a tool for accessing MMS API"
-app_usage = "#{app_name} command [options]"
-app_version = MMS::VERSION
-app_commands = "#{actions_available.join(' | ')}"
-
-config = {}
-options = {}
-
-config_file = Pathname.new(Dir.home) + app_name.prepend('.')
-if config_file.exist?
-  config = ParseConfig.new(config_file)
-end
-
-optparse = OptionParser.new do |opts|
-  opts.banner = "#{app_dscr}\n\nUsage:\n\n\t#{app_usage}\n\nCommands:\n\n\t#{app_commands}\n\nOptions:\n\n"
-
-  options[:username] = config['username']
-  opts.on("-u", "--username <string>", "MMS user") do |u|
-    options[:username] = u
-  end
-
-  options[:apikey] = config['apikey']
-  opts.on("-k", "--apikey <string>", "MMS api-key") do |k|
-    options[:apikey] = k
-  end
-
-  options[:apiurl] = config['apiurl']
-  opts.on("-a", "--apiurl <string>", "MMS api url. Full url including version: https://mms.mydomain.tld/api/public/v1.0") do |a|
-    options[:apiurl] = a
-  end
-
-  options[:name] = '.*'
-  opts.on("-n", "--name <string>", "Filter for resource name using regexp") do |n|
-    options[:name] = n
-  end
-
-  options[:limit] = config['limit'] || 5
-  opts.on("-l", "--limit <int>", "Limit for result items") do |l|
-    options[:limit] = l.to_i
-  end
-
-  opts.on("-v", "--version", "Version") do |v|
-    puts "#{app_name} v#{app_version}"
-    exit
-  end
-
-  opts.on("-h", "--help", "Show this help") do |h|
-    puts opts
-    exit
-  end
-end
-
-begin
-  optparse.parse!
-  if not options[:username]
-    puts "Missing options: MMS username [-u <string>]"
-    exit
-  end
-  if not options[:apikey]
-    puts "Missing options: MMS api-key [-k <string>]"
-    exit
-  end
-rescue OptionParser::InvalidOption, OptionParser::MissingArgument
-  puts $!.to_s
-  puts optparse
-  exit
-end
-
-begin
-  action = (ARGV.first || config['action'] || '').downcase
-  raise("Unknown action #{action.upcase}") unless actions_available.include? (action)
-rescue => e
-  puts "Error: #{e.message}"
-  puts "Available actions: #{(actions_available.join ', ').upcase}"
-  puts optparse
-  exit 1
-end
-
-begin
-  ARGV.shift
-  agent = MMS::Agent.new(options[:username], options[:apikey])
-  if options[:apiurl] then
-    agent.set_apiurl(options[:apiurl])
-  end
-
-  results = agent.send action.sub('-', '_'), *ARGV
-  results.select! { |resource| !resource.name.match(Regexp.new(options[:name])).nil? }
-
-  rows = []
-  case action
-    when 'groups'
-      heading = ['Name', 'Active Agents', 'Replicas count', 'Shards count', 'Last Active Agent', 'GroupId']
-      results.each do |group|
-        rows << [group.name, group.active_agent_count, group.replicaset_count, group.shard_count, group.last_active_agent, group.id]
-      end
-    when 'hosts'
-      heading = ['Group', 'Type', 'Hostname', 'IP', 'Port', 'Last ping', 'Alerts enabled', 'HostId', 'Shard', 'Replica']
-      results.each do |host|
-        rows << [host.group.name, host.type_name, host.name, host.ip_address, host.port, host.last_ping, host.alerts_enabled, host.id, host.shard_name, host.replicaset_name]
-      end
-    when 'clusters'
-      heading = ['Group', 'Cluster', 'Shard name', 'Replica name', 'Type', 'Last heartbeat', 'Cluster Id']
-      results.each do |cluster|
-        rows << [cluster.group.name, cluster.name, cluster.shard_name, cluster.replicaset_name, cluster.type_name, cluster.last_heartbeat, cluster.id]
-      end
-    when 'snapshots'
-      heading = ['Group', 'Cluster', 'SnapshotId', 'Complete', 'Created increment', 'Name (created date)', 'Expires']
-      results_sorted = results.sort_by { |snapshot| snapshot.created_date }.reverse
-      results_sorted.first(options[:limit]).each do |snapshot|
-        rows << [snapshot.cluster.group.name, snapshot.cluster.name, snapshot.id, snapshot.complete, snapshot.created_increment, snapshot.name, snapshot.expires]
-        rows << :separator
-        part_count = 0
-        snapshot.parts.each do |part|
-          file_size_mb = part['fileSizeBytes'].to_i / (1024*1024)
-          rows << [{:value => "part #{part_count}", :colspan => 4, :alignment => :right}, part['typeName'], part['replicaSetName'], "#{file_size_mb} MB"]
-          part_count += 1
-        end
-        rows << :separator
-      end
-    when 'restorejobs', 'restorejobs-create'
-      heading = ['RestoreId', 'SnapshotId / Cluster / Group', 'Name (created)', 'Status', 'Point in time', 'Delivery', 'Restore status']
-      results_sorted = results.sort_by { |job| job.created }.reverse
-      results_sorted.first(options[:limit]).each do |job|
-        rows << [job.id, job.snapshot_id, job.name, job.status_name, job.point_in_time, job.delivery_method_name, job.delivery_status_name]
-        rows << ['', "#{job.cluster.name} (#{job.cluster.id})", {:value => '', :colspan => 5}]
-        rows << ['', job.cluster.group.name, {:value => '', :colspan => 5}]
-        rows << [{:value => 'download url:', :colspan => 7}]
-        rows << [{:value => job.delivery_url, :colspan => 7}]
-        rows << :separator
-      end
-  end
-
-  puts Terminal::Table.new :title => action.upcase, :headings => (heading.nil? ? [] : heading), :rows => rows
 
-rescue => e
-  puts "Error: `#{e.message}`"
-  exit 1
-end
+MMS::CLI::CommandManager.run

data/lib/mms.rb

@@ -1,15 +1,28 @@
 module MMS
   require 'rubygems'  # For ruby < 1.9
 
+  require "uri"
+  require "json"
+  require "cgi"
+  require "net/http"
+  require 'net/http/digest_auth'
+  require 'terminal-table'
+  require 'pathname'
+
+  require 'mms/config'
   require 'mms/agent'
   require 'mms/client'
   require 'mms/cache'
   require 'mms/version'
   require 'mms/resource'
+  require 'mms/errors'
 
   require 'mms/resource/group'
   require 'mms/resource/host'
   require 'mms/resource/cluster'
   require 'mms/resource/snapshot'
   require 'mms/resource/restore_job'
+  require 'mms/resource/alert'
+
+  require 'mms/cli'
 end

data/lib/mms/agent.rb

@@ -2,37 +2,18 @@ module MMS
 
   class Agent
 
-    def initialize(username, apikey)
-      MMS::Client.instance.auth_setup(username, apikey)
+    attr_accessor :client
+
+    def initialize(client)
+      @client = client
     end
 
     def set_apiurl(apiurl)
-      begin
-        url_info = URI(apiurl)
-      rescue URI::InvalidURIError
-        puts "Unable to parse given apiurl: #{apiurl}"
-        exit
-      end
-
-      # Split out version from URL path
-      path_parts = url_info.path.split '/'
-      api_version = path_parts.pop
-      url_info.path = path_parts.join '/'
-
-      # Update client singleton
-      MMS::Client.instance.api_protocol = url_info.scheme
-      MMS::Client.instance.api_host = url_info.host
-      MMS::Client.instance.api_port = url_info.port
-      MMS::Client.instance.api_path = url_info.path
-      MMS::Client.instance.api_version = api_version
+      @client.url = apiurl
     end
 
     def groups
-      group_list = []
-      MMS::Client.instance.get('/groups').each do |group|
-        group_list.push MMS::Resource::Group.new group['id'], group
-      end
-      group_list
+      MMS::Resource::Group.findGroups(@client)
     end
 
     def hosts
@@ -56,7 +37,15 @@ module MMS
       clusters.each do |cluster|
         snapshot_list.concat cluster.snapshots
       end
-      snapshot_list
+      snapshot_list.sort_by { |snapshot| snapshot.created_date }.reverse
+    end
+
+    def alerts
+      alert_list = []
+      groups.each do |group|
+        alert_list.concat group.alerts
+      end
+      alert_list.sort_by { |alert| alert.created }.reverse
     end
 
     def restorejobs
@@ -64,15 +53,36 @@ module MMS
       clusters.each do |cluster|
         restorejob_list.concat cluster.restorejobs
       end
-      restorejob_list
+      restorejob_list.sort_by { |job| job.created }.reverse
     end
 
-    def restorejobs_create(group_id, cluster_id, snapshot_id)
-      findGroup(group_id).cluster(cluster_id).snapshot(snapshot_id).create_restorejob
+    def restorejob_create(type_value, group_id, cluster_id)
+      if type_value.length == 24
+        findGroup(group_id).cluster(cluster_id).snapshot(type_value).create_restorejob
+      elsif datetime = (type_value == 'now' ? DateTime.now : DateTime.parse(type_value))
+        raise('Invalid datetime. Correct `YYYY-MM-RRTH:m:s`') if datetime.nil?
+        datetime_string = [[datetime.year, datetime.day, datetime.month].join('-'), 'T', [datetime.hour, datetime.minute, datetime.second].join(':'), 'Z'].join
+        findGroup(group_id).cluster(cluster_id).create_restorejob(datetime_string)
+      end
+    end
+
+    def alert_ack(alert_id, timestamp, group_id)
+      timestamp = DateTime.now if timestamp == 'now'
+      timestamp = DateTime.new(4000, 1, 1, 1, 1, 1, 1, 1) if timestamp == 'forever'
+
+      group = findGroup(group_id)
+
+      if alert_id == 'all'
+        group.alerts.each do |alert|
+          alert.ack(timestamp, 'Triggered by CLI for all alerts.')
+        end
+      elsif group.alert(alert_id).ack(timestamp, 'Triggered by CLI.')
+      end
     end
 
     def findGroup(id)
-      MMS::Resource::Group.new id
+      MMS::Resource::Group.new(@client, {'id' => id})
     end
+
   end
 end

data/lib/mms/cli.rb

@@ -0,0 +1,258 @@
+require 'clamp'
+require 'parseconfig'
+
+module MMS
+
+  class CLI
+
+    class MMS::CLI::Command < Clamp::Command
+
+      attr_accessor :app_name
+      attr_accessor :config
+
+      attr_accessor :client
+      attr_accessor :agent
+
+      option ['-u', '--username'], '<string>', 'MMS user' do |u|
+        @config.username = u
+      end
+
+      option ['-k', '--apikey'], '<string>', 'MMS api-key' do |a|
+        @config.apikey = a
+      end
+
+      option ['-a', '--apiurl'], '<string>', 'MMS api url. Full url including version: https://mms.mydomain.tld/api/public/v1.0' do |u|
+        @config.apiurl = u
+      end
+
+      option ['-v', '--version'], :flag, 'Version' do |v|
+        puts "mms-api v#{MMS::VERSION}"
+        exit
+      end
+
+      option ['-g', '--default-group-id'], '<string>', 'Default MMS group id' do |g|
+        @config.default_group_id = g
+      end
+
+      option ['-c', '--default-cluster-id'], '<string>', 'Default MMS cluster id' do |c|
+        @config.default_cluster_id = c
+      end
+
+      option ['--cfg'], '<string>', 'Config file path' do |p|
+        @config.config_path = p
+        parse_user_home_config
+      end
+
+      option ['-i', '--ignore'], :flag, 'Ignore flag of --group-id and -cluster-id', :default => false
+
+      option ['-j', '--json'], :flag, 'Print JSON output', :default => false
+
+      option ['-l', '--limit'], '<integer>', 'Limit for result items' do |l|
+        @config.limit = Integer(l)
+      end
+
+      def initialize(invocation_path, context = {}, parent_attribute_values = {})
+        @config ||= MMS::Config.new
+      end
+
+      def parse_user_home_config
+        raise(MMS::ConfigError.new('Config file path is not set!')) if @config.config_path.nil?
+        config_file = Pathname.new(@config.config_path)
+        raise(MMS::ConfigError.new("Config file `#{config_file}` does not exist")) unless config_file.exist?
+
+        config = ParseConfig.new(config_file)
+        config.params.map do |key, value|
+          begin
+            @config.send("#{key}=", value)
+          rescue Exception => e
+            raise MMS::ConfigError.new("Config option `#{key}` from file `#{config_file}` is not allowed!")
+          end
+        end
+
+      end
+
+      def agent
+        @client = MMS::Client.new(@config.username, @config.apikey)
+        @agent = MMS::Agent.new(client)
+      end
+
+      def print(heading, resource_list)
+        json? ? print_json(resource_list) : print_human(heading, resource_list)
+      end
+
+      def print_human(heading, resource_list)
+        rows = []
+
+        resource_list.first(@config.limit).each do |resource|
+          rows += resource.table_section
+        end
+
+        puts Terminal::Table.new :title => 'Hosts', :headings => (heading.nil? ? [] : heading), :rows => rows
+
+        print_tips unless ignore?
+      end
+
+      def print_json(resource_list)
+        rows = []
+
+        resource_list.first(@config.limit).each do |resource|
+          rows.push(resource.to_hash)
+        end
+
+        puts JSON.pretty_generate(rows)
+      end
+
+      def print_tips
+        puts 'Default group: ' + @config.default_group_id unless @config.default_group_id.nil?
+        puts 'Default cluster: ' + @config.default_cluster_id unless @config.default_cluster_id.nil?
+
+        if !@config.default_group_id.nil? or !@config.default_cluster_id.nil?
+          puts "Add flag --ignore or update --default-group-id, --default-cluster-id or update your `#{@config.config_path}` to see all resources"
+        end
+      end
+
+      def run(arguments)
+        begin
+          parse_user_home_config
+          super
+        rescue Clamp::HelpWanted => e
+          raise(help)
+        rescue Clamp::UsageError => e
+          raise([e.message, help].join("\n"))
+        rescue MMS::AuthError => e
+          raise('Authorisation problem. Please check you credential!')
+        rescue MMS::ResourceError => e
+          raise(["Resource #{e.resource.class.name} problem:", e.message].join("\n"))
+        end
+      end
+    end
+
+    class MMS::CLI::Command::Hosts < MMS::CLI::Command
+
+      subcommand 'list', 'Host list' do
+
+        def execute
+          print(MMS::Resource::Host.table_header, agent.hosts)
+        end
+      end
+
+    end
+
+    class MMS::CLI::Command::Groups < MMS::CLI::Command
+
+      subcommand 'list', 'Group list' do
+
+        def execute
+
+          group_list = agent.groups
+          group_list.reject! { |group| group.id != @config.default_group_id } unless @config.default_group_id.nil? or ignore?
+
+          print(MMS::Resource::Group.table_header, group_list)
+        end
+      end
+
+    end
+
+    class MMS::CLI::Command::Clusters < MMS::CLI::Command
+
+      subcommand 'list', 'Cluster list' do
+
+        def execute
+          cluster_list = agent.clusters
+          cluster_list.reject! { |cluster| cluster.id != @config.default_cluster_id } unless @config.default_cluster_id.nil? or ignore?
+
+          print(MMS::Resource::Cluster.table_header, cluster_list)
+        end
+      end
+
+    end
+
+
+    class MMS::CLI::Command::Alerts < MMS::CLI::Command
+
+      subcommand 'list', 'Alerts list' do
+
+        def execute
+          print(MMS::Resource::Alert.table_header, agent.alerts)
+        end
+
+      end
+
+      subcommand 'ack', 'Acknowledge alert' do
+
+        parameter '[alert-id]', 'Alert ID', :default => 'all'
+        parameter '[group-id]', 'Group ID', :default => '--default-group-id'
+        parameter '[timestamp]', 'Postpone to timestamp', :default => 'forever'
+
+        def execute
+          g_id = group_id == '--default-group-id' ? @config.default_group_id : group_id
+          agent.alert_ack(alert_id, timestamp, g_id)
+          puts 'Done.'
+        end
+
+      end
+
+    end
+
+    class MMS::CLI::Command::Snapshots < MMS::CLI::Command
+
+      subcommand 'list', 'Snapshot list' do
+
+        def execute
+          print(MMS::Resource::Snapshot.table_header, agent.snapshots)
+        end
+      end
+
+    end
+
+    class MMS::CLI::Command::RestoreJobs < MMS::CLI::Command
+
+      subcommand 'list', 'Restorejob list' do
+
+        def execute
+          print(MMS::Resource::RestoreJob.table_header, agent.restorejobs)
+        end
+
+      end
+
+      subcommand 'create', 'Restorejob create' do
+
+        parameter '[snapshot-source]', 'Restore from source. Options: now | timestamp | snapshot-id', :default => 'now'
+        parameter '[group-id]', 'Group ID', :default => '--default-group-id'
+        parameter '[cluster-id]', 'Cluster ID', :default => '--default-cluster-id'
+
+        def execute
+          g_id = group_id == '--default-group-id' ? @config.default_group_id : group_id
+          c_id = cluster_id == '--default-cluster-id' ? @config.default_cluster_id : cluster_id
+
+          agent.restorejob_create(snapshot_source, g_id, c_id)
+
+          puts 'Done.'
+        end
+
+      end
+
+    end
+
+    class MMS::CLI::CommandManager < MMS::CLI::Command
+
+      def run(arguments)
+        begin
+          super
+        rescue Exception => e
+          abort(e.message.empty? ? 'Unknown error/Interrupt' : e.message)
+        end
+      end
+
+      subcommand 'groups', 'Groups ', MMS::CLI::Command::Groups
+      subcommand 'hosts', 'Hosts', MMS::CLI::Command::Hosts
+      subcommand 'clusters', 'Clusters', MMS::CLI::Command::Clusters
+      subcommand 'alerts', 'Alerts', MMS::CLI::Command::Alerts
+      subcommand 'snapshots', 'Snapshots', MMS::CLI::Command::Snapshots
+      subcommand 'restorejobs', 'Restorejobs', MMS::CLI::Command::RestoreJobs
+
+    end
+
+  end
+
+end