dldinternet-opensrs 0.3.0

data/lib/dldinternet/opensrs/api/domain/mixins/zone/setdnszone.rb

@@ -0,0 +1,35 @@
+require 'hashie/mash'
+
+module DLDInternet
+  module OpenSRS
+    module API
+      module Domain
+        module MixIns
+          module Zone
+            module SetDNSZone
+
+              # noinspection RubyUnnecessaryReturnValue
+              def SetDomainDNSZone(domain,records,cookiep=nil,registrant_ip=nil)
+
+                data = {
+                    object: 'DOMAIN',
+                    action: 'set_dns_zone',
+                    attributes: {
+                        domain: domain,
+                        records: records,
+                    },
+                }
+                data[:cookie]             = cookiep if cookiep
+                data[:domain]             = domain
+                data[:registrant_ip]      = registrant_ip if registrant_ip
+
+                getResponse(data)
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/api/domain/modify.rb

@@ -0,0 +1,19 @@
+require 'dldinternet/opensrs/api/base'
+
+module DLDInternet
+  module OpenSRS
+    module API
+      module Domain
+        class Modify < DLDInternet::OpenSRS::API::Base
+
+        require 'dldinternet/opensrs/api/domain/mixins/modify/domainlockstate'
+        include DLDInternet::OpenSRS::API::Domain::MixIns::Modify::DomainLockState
+
+        require 'dldinternet/opensrs/api/domain/mixins/modify/domainassign_ns'
+        include DLDInternet::OpenSRS::API::Domain::MixIns::Modify::DomainAssignNS
+
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/api/domain/zone.rb

@@ -0,0 +1,19 @@
+require 'dldinternet/opensrs/api/base'
+
+module DLDInternet
+  module OpenSRS
+    module API
+      module Domain
+        class Zone < DLDInternet::OpenSRS::API::Base
+
+          require 'dldinternet/opensrs/api/domain/mixins/zone/getdnszone'
+          include DLDInternet::OpenSRS::API::Domain::MixIns::Zone::GetDNSZone
+
+          require 'dldinternet/opensrs/api/domain/mixins/zone/setdnszone'
+          include DLDInternet::OpenSRS::API::Domain::MixIns::Zone::SetDNSZone
+
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/api/domain.rb

@@ -0,0 +1,3 @@
+require 'dldinternet/opensrs/api/domain/get'
+require 'dldinternet/opensrs/api/domain/modify'
+require 'dldinternet/opensrs/api/domain/zone'

data/lib/dldinternet/opensrs/api/mixins/cookie.rb

@@ -0,0 +1,46 @@
+require 'hashie/mash'
+
+module DLDInternet
+  module OpenSRS
+    module API
+      module MixIns
+        module Cookie
+
+          def cookie(domain='delionsden.com')
+            domain ||= 'dldinternet.com'
+            @cookie ||= (
+            response = server.call(
+                action: 'SET',
+                object: 'COOKIE',
+                attributes: {
+                    domain: domain,
+                    reg_username: options[:username],
+                    reg_password: options[:password],
+                },
+            )
+            hash = Hashie::Mash.new(response.response)
+            @logger.debug.ai
+            unless hash['is_success'].to_i == 1
+              @logger.fatal StandardError.new(hash['response_text'])
+              exit 1
+            end
+            hash['attributes']['cookie'] rescue nil)
+          rescue ::OpenSRS::BadResponse => e
+            @logger.error e.message
+            exit 1
+          rescue ::Net::HTTPServerException => e
+            @logger.error "#{e.message}: #{(e.response && e.response[:body]) ? e.response.body : ''}"
+            exit 1
+          rescue SystemExit => e
+            exit e.status
+          rescue StandardError => e
+            raise e
+          rescue Exception => e
+            @logger.error "Unknown exception: #{e}"
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/api/nameservers/get.rb

@@ -0,0 +1,16 @@
+require 'dldinternet/opensrs/api/base'
+
+module DLDInternet
+  module OpenSRS
+    module API
+      module NameServers
+        class Get < DLDInternet::OpenSRS::API::Base
+
+          require 'dldinternet/opensrs/api/nameservers/mixins/get/getnameservers'
+          include DLDInternet::OpenSRS::API::NameServers::MixIns::Get::GetNameServers
+
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/api/nameservers/mixins/get/getnameservers.rb

@@ -0,0 +1,61 @@
+require 'hashie/mash'
+
+module DLDInternet
+  module OpenSRS
+    module API
+      module NameServers
+        module MixIns
+          module Get
+            module GetNameServers
+
+              # noinspection RubyUnnecessaryReturnValue
+              def GetNameServers(domain=nil,cookiep=nil, attr='nameserver_list')
+
+                list = []
+                limit = 25
+                pn = 0
+                pgnos = nil
+                page = getnameserverspage(domain, cookiep || cookie(domain), nil, nil, limit)
+                while page && page.is_a?(Hash)
+                  list += page[attr]
+                  pgnos ||= page['count'].to_i/limit
+                  if page['remainder'].eql?('1') && pn < pgnos
+                    pn += 1
+                    page = getdomainpage(domain, cookiep || cookie, nil, pn, limit)
+                  else
+                    page = nil
+                  end
+                end
+                list
+              end
+
+              private
+
+              # noinspection RubyUnnecessaryReturnValue
+              def getnameserverspage(domain=nil,cookiep=nil,registrant_ip=nil, page=nil, limit=nil)
+
+                data = {
+                    object: 'nameserver',
+                    action: 'get',
+                    cookie: (cookiep || cookie(domain)),
+                    attributes: {
+                        name: 'all',
+                        domain: domain,
+                    },
+                }
+                data[:cookie]             = cookiep if cookiep
+                data[:domain]             = domain if domain && !cookiep
+                data[:registrant_ip]      = registrant_ip if registrant_ip
+                data[:attributes][:limit] = limit if limit
+                data[:attributes][:page]  = page if page
+
+                getResponse(data)
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/api/nameservers.rb

@@ -0,0 +1 @@
+require 'dldinternet/opensrs/api/nameservers/get'

data/lib/dldinternet/opensrs/domain/command.rb

@@ -0,0 +1,27 @@
+require 'dldinternet/opensrs/domain/get/command'
+require 'dldinternet/opensrs/domain/modify/command'
+require 'dldinternet/opensrs/domain/zone/command'
+
+module DLDInternet
+  module OpenSRS
+    module Domain
+      class Command < DLDInternet::Thor::Command
+        no_commands do
+
+          require 'dldinternet/opensrs/domain/mixins/no_commands'
+          include DLDInternet::OpenSRS::Domain::MixIns::NoCommands
+
+        end
+
+        desc 'get SUBCOMMAND ... ARGS', 'get domain stuff'
+        subcommand 'get', ::DLDInternet::OpenSRS::Domain::Get::Command
+
+        desc 'modify SUBCOMMAND ... ARGS', 'manipulate domains'
+        subcommand 'modify', ::DLDInternet::OpenSRS::Domain::Modify::Command
+
+        desc 'zone SUBCOMMAND ... ARGS', 'manipulate domains'
+        subcommand 'zone', ::DLDInternet::OpenSRS::Domain::Zone::Command
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/get/command.rb

@@ -0,0 +1,85 @@
+require 'dldinternet/opensrs/api/domain'
+
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module Get
+        class Command < DLDInternet::Thor::Command
+          no_commands do
+
+            require 'dldinternet/opensrs/domain/get/mixins/no_commands'
+            include DLDInternet::OpenSRS::Domain::Get::MixIns::NoCommands
+
+          end
+
+          desc 'all_info', 'all domain info'
+          def all_info(domain)
+            command_pre(domain)
+
+            answer = DLDInternet::OpenSRS::API::Domain::Get.new(options, @logger).GetAllInfo(domain)
+            case @config[:format].to_s
+            when /none|text/
+              @config[:format] = :awesome
+            end
+            command_out answer
+            0
+          end
+
+          desc 'list', 'list domains'
+          def list()
+            command_pre()
+            @header = ->{ sprintf("%-48s", 'Domainname') }
+            @format = ->(res) { sprintf("%-48s", res ) }
+
+            answer = DLDInternet::OpenSRS::API::Domain::Get.new(options, @logger).GetDomainList
+            command_out answer
+            0
+          end
+
+          desc 'nameservers DOMAIN', 'domain dns'
+          def nameservers(domain)
+            dns(domain)
+          end
+
+          desc 'dns DOMAIN', 'domain dns'
+          def dns(domain)
+            command_pre(domain)
+            @header = ->{ sprintf("%-10s\t%-48s", 'Nameserver','Hostname') }
+            @format = ->(res) { sprintf("%-10s\t%-48s", res['sortorder'], res['name'] ) }
+
+            answer = DLDInternet::OpenSRS::API::Domain::Get.new(options, @logger).GetDomainNameservers(domain).sort_by { |ns| ns['sortorder'].to_i }
+            case @config[:format].to_s
+            when /text|none/
+              @header = ->{ sprintf("#{domain}\n%-10s\t%-48s", 'Nameserver','Hostname') }
+              # output domain
+              # output answer.sort_by { |ns| ns['sortorder'].to_i }.each { |ns| write "nameserver #{ns['sortorder']}: #{ns['name']}" }
+            # else
+            #   output answer
+            end
+            command_out answer
+            0
+          end
+
+          desc 'status DOMAIN', 'domain status'
+          def status(domain)
+            command_pre domain
+            @header = ->{ sprintf("%-10s\t%-10s\t%-14s", 'Lock state','Can modify','Domain supports') }
+            @format = ->(res) { sprintf("%-10s\t%-10s\t%-14s", res['lock_state'], res['can_modify'], res['domain_supports'] ) }
+
+            answer = DLDInternet::OpenSRS::API::Domain::Get.new(options, @logger).GetDomainStatus(domain)
+            case @config[:format].to_s
+            when /text|none/
+              @header = ->{ sprintf("#{domain}\n%-10s\t%-10s\t%-14s", 'Lock state','Can modify','Domain supports') }
+              # write domain
+              # answer.each { |k,v| write "#{k}: #{v}" }
+            # else
+            #   output answer
+            end
+            command_out answer
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/get/mixins/no_commands.rb

@@ -0,0 +1,16 @@
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module Get
+        module MixIns
+          module NoCommands
+
+            require 'dldinternet/opensrs/domain/mixins/no_commands'
+            include DLDInternet::OpenSRS::Domain::MixIns::NoCommands
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/mixins/no_commands.rb

@@ -0,0 +1,12 @@
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module MixIns
+        module NoCommands
+          require 'dldinternet/opensrs/mixins/no_commands'
+          include DLDInternet::OpenSRS::MixIns::NoCommands
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/modify/command.rb

@@ -0,0 +1,40 @@
+require 'dldinternet/opensrs/api/domain'
+
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module Modify
+        class Command < DLDInternet::Thor::Command
+          no_commands do
+
+            require 'dldinternet/opensrs/domain/modify/mixins/no_commands'
+            include DLDInternet::OpenSRS::Domain::Modify::MixIns::NoCommands
+
+          end
+
+          desc 'lock_state', 'modify domain lock_state'
+          def lock_state(domain, state)
+            parse_options
+            @logger.info "domain lock_state for #{domain} = #{state}" if options[:verbose]
+
+            answer = DLDInternet::OpenSRS::API::Domain::Modify.new(options, @logger).SetDomainLockState(domain, state)
+            puts domain
+            puts answer.ai
+            0
+          end
+
+          desc 'assign_ns', 'modify domain nameservers'
+          def assign_ns(domain, nameserverscsv)
+            parse_options
+            @logger.info "domain assign_ns for #{domain} = #{nameserverscsv}" if options[:verbose]
+
+            answer = DLDInternet::OpenSRS::API::Domain::Modify.new(options, @logger).AssignDomainNameServers(domain, nameserverscsv)
+            puts domain
+            puts answer.ai
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/modify/mixins/no_commands.rb

@@ -0,0 +1,16 @@
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module Modify
+        module MixIns
+          module NoCommands
+
+            require 'dldinternet/opensrs/domain/mixins/no_commands'
+            include DLDInternet::OpenSRS::Domain::MixIns::NoCommands
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/zone/command.rb

@@ -0,0 +1,188 @@
+require 'dldinternet/opensrs/api/domain'
+
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module Zone
+        class Command < DLDInternet::Thor::Command
+          no_commands do
+
+            require 'dldinternet/opensrs/domain/zone/mixins/no_commands'
+            include DLDInternet::OpenSRS::Domain::Zone::MixIns::NoCommands
+
+            def showDNSZoneAnswer(answer,domain)
+              if answer['records']
+                case @config[:format].to_s
+                when /none|text/
+                  #@config[:format] = :awesome
+                  output domain if options[:verbose]
+                  output header_line unless options[:header] === false
+                  width = 32
+                  answer['records'].map { |type,list|
+                    list.map{ |entry|
+                      case type
+                      when %r'^A'
+                        output sprintf("%#{width}s\t%3s\t%3s\t%s", entry['subdomain'], type, '', entry['ip_address'])
+                      when 'MX'
+                        output sprintf("%#{width}s\t%3s\t%3s\t%s", entry['subdomain'], type, entry['priority'], entry['hostname'])
+                      when 'SRV'
+                        output sprintf("%#{width}s\t%3s\t%3s\t%s\t%s\t%s", entry['subdomain'], type, entry['priority'], entry['weight'], entry['hostname'], entry['port'])
+                      when 'TXT'
+                        output sprintf("%#{width}s\t%3s\t%3s\t%s", entry['subdomain'], type, '', entry['text'])
+                      when 'CNAME'
+                        output sprintf("%#{width}s\t%3s\t%3s\t%s", entry['subdomain'], type, '', entry['hostname'])
+                      else
+                        output "#{type}\t#{entry.to_s}"
+                      end
+                    }
+                  }
+                else
+                  output answer
+                end
+              else
+                output answer
+              end
+            end
+
+            # noinspection RubyStringKeysInHashInspection
+            def mapDNSZoneAnswer(answer,domain)
+              if answer['records']
+                case @config[:format].to_s
+                when /none|text|awesome/
+                  records = []
+                  answer['records'].each { |type,list|
+                    list.each { |entry|
+                      case type
+                      when %r'^A'
+                        records << { 'subdomain' => entry['subdomain'], 'type' => type, 'priority' => '', 'data' => entry['ip_address'], 'weight' => '', 'port' => '' }
+                      when 'MX'
+                        records << { 'subdomain' => entry['subdomain'], 'type' => type, 'priority' => entry['priority'], 'data' => entry['hostname'], 'weight' => '', 'port' => '' }
+                      when 'SRV'
+                        records << { 'subdomain' => entry['subdomain'], 'type' => type, 'priority' => entry['priority'], 'data' => entry['hostname'], 'weight' => entry['weight'], 'port' => entry['port'] }
+                      when 'TXT'
+                        records << { 'subdomain' => entry['subdomain'], 'type' => type, 'priority' => '', 'data' => entry['text'], 'weight' => '', 'port' => '' }
+                      when 'CNAME'
+                        records << { 'subdomain' => entry['subdomain'], 'type' => type, 'priority' => '', 'data' => entry['hostname'], 'weight' => '', 'port' => '' }
+                      else
+                        records << { 'subdomain' => '', 'type' => type, 'priority' => '', 'data' => entry.to_s, 'weight' => '', 'port' => '' }
+                      end
+                    }
+                  }
+                  records
+                else
+                  answer['records']
+                end
+              end
+            end
+
+          end
+
+          desc 'get', 'domain zone info'
+          def get(domain)
+            command_pre(domain)
+            zone_records_format
+            answer = DLDInternet::OpenSRS::API::Domain::Zone.new(options, @logger).GetDomainDNSZone(domain)
+            # showDNSZoneAnswer(answer, domain)
+            res = mapDNSZoneAnswer(answer, domain)
+            command_out(res)
+            0
+          end
+
+          desc 'set', 'domain zone set'
+          def set(domain, info)
+            command_pre(domain)
+            zone_records_format
+
+            answer = DLDInternet::OpenSRS::API::Domain::Zone.new(options, @logger).GetDomainDNSZone(domain)
+            if answer['records']
+              records = answer['records']
+              delta = nil
+              begin
+                delta = JSON.parse(File.exists?(info) ? File.read(info) : info)
+                op = '='
+              rescue JSON::ParserError => e
+                logger.debug e.ai
+                matches = info.match(%r{^([+\-]*)([a-z\.0-9]*)\s*(A|AAAA|CNAME|MX|SRV|TXT)\s+(.*)$})
+                if matches
+                  logger.debug matches.ai
+                  _, op, subdomain, type, ip_address = matches.to_a
+                  op = '+' if op.nil? || op.empty?
+                  case type
+                  when /^A+/
+                    delta = { 'A' => [ { 'ip_address' => ip_address } ] }
+                    delta['A'][0]['subdomain'] = subdomain unless subdomain.empty?
+                  when 'CNAME'
+                    raise "ERROR: #{type} not implemented"
+                  when 'MX'
+                    raise "ERROR: #{type} not implemented"
+                  when 'SRV'
+                    raise "ERROR: #{type} not implemented"
+                  when 'TXT'
+                    raise "ERROR: #{type} not implemented"
+                  else
+                    raise "ERROR: #{info} cannot be parsed!"
+                  end
+                else
+                  delta = {}
+                end
+              end
+              logger.info delta.ai
+              if op == '='
+                records = delta
+              else
+                delta.each do |typ,lst|
+                  lst.each{ |ent|
+                    case typ
+                    when %r'^A'
+                      case op
+                      when  '+'
+                        existing = records[typ].select { |rec|
+                          (ent['subdomain'] && ent['subdomain'].eql?(rec['subdomain'])) ||
+                              (ent['subdomain'].nil? && rec['subdomain'].nil?)
+                        }
+                        logger.warn existing.ai
+                        if existing.size > 0
+                          existing.each do |rec|
+                            rec['ip_address'] = ent['ip_address']
+                          end
+                        else
+                          records[typ].push(ent)
+                        end
+                      when '-'
+                        records[typ] = records[typ].select { |rec|
+                          ((ent['subdomain'] && !ent['subdomain'].eql?(rec['subdomain'])) ||
+                              (ent['subdomain'].nil? && rec['subdomain'].nil?)) && !ent['ip_address'].eql?(rec['ip_address'])
+                        }
+                      else
+                        logger.error "Invalid operation: #{op}"
+                        raise
+                      end
+                    when 'MX'
+                      raise "#{typ} update not implemented"
+                    when 'SRV'
+                      raise "#{typ} update not implemented"
+                    when 'TXT'
+                      raise "#{typ} update not implemented"
+                    when 'CNAME'
+                    else
+                      logger.error "Unknown entry: #{ent}"
+                      raise
+                    end
+                  }
+                end
+              end
+              logger.debug records.ai
+              answer = DLDInternet::OpenSRS::API::Domain::Zone.new(options, @logger).SetDomainDNSZone(domain,records)
+              # showDNSZoneAnswer(answer, domain)
+              res = mapDNSZoneAnswer(answer, domain)
+              command_out(res)
+            else
+              logger.error "Unable to retrieve DNS zone info for #{domain}"
+            end
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/domain/zone/mixins/no_commands.rb

@@ -0,0 +1,28 @@
+module DLDInternet
+  module OpenSRS
+    module Domain
+      module Zone
+        module MixIns
+          module NoCommands
+
+            require 'dldinternet/opensrs/domain/mixins/no_commands'
+            include DLDInternet::OpenSRS::Domain::MixIns::NoCommands
+
+=begin
+            f556592444564103d2c17317bebca3de.ds1	CNAME	        	896e2ecc4a5528f39b306a5bb96afaedc7bf7824.comodoca.com
+=end
+            def zone_records_format(*args)
+              if args.size > 0
+                raise "TODO: Set column widths to fit data"
+              else
+                @header = -> { sprintf("%-48s\t%-5s\t%-8s\t%-64s\t%-5s\t%-5s", 'Subdomain', 'Type', 'Priority', 'Host', 'Weight', 'Port') }
+                @format = ->(res) { sprintf("%-48s\t%-5s\t%-8s\t%-64s\t%-5s\t%-5s", res['subdomain'], res['type'], res['priority'], res['data'], res['weight'], res['port']) }
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dldinternet/opensrs/main.rb

@@ -0,0 +1,26 @@
+require 'dldinternet/thor/command'
+require 'dldinternet/opensrs/domain/command'
+require 'dldinternet/opensrs/nameservers/command'
+
+module DLDInternet
+  module OpenSRS
+    class Main < DLDInternet::Thor::Command
+      class_option :verbose,      type: :boolean
+      class_option :debug,        type: :boolean
+      class_option :trace,        type: :boolean
+      class_option :log_level,    type: :string, banner: 'Log level ([:trace, :debug, :info, :step, :warn, :error, :fatal, :todo])'
+      class_option :server,       type: :string, default: "https://rr-n1-tor.opensrs.net:55443"
+      class_option :username,     type: :string, default: 'dldinternet'
+      class_option :password,     type: :string
+      class_option :key,          type: :string
+      class_option :inifile,      type: :string, default: '~/.opensrs.ini'
+      class_option :format,       type: :string, default: :none, aliases: [ '--output']
+
+      desc 'domain SUBCOMMAND ... ARGS', 'do domains'
+      subcommand 'domain', ::DLDInternet::OpenSRS::Domain::Command
+
+      desc 'nameservers SUBCOMMAND ... ARGS', 'do domains'
+      subcommand 'nameservers', ::DLDInternet::OpenSRS::NameServers::Command
+    end
+  end
+end

data/lib/dldinternet/opensrs/mixins/no_commands.rb

@@ -0,0 +1,10 @@
+module DLDInternet
+  module OpenSRS
+
+    module MixIns
+      module NoCommands
+
+      end
+    end
+  end
+end