ConfigLMM 0.1.0

data/Plugins/Platforms/GitHub.lmm.rb

@@ -0,0 +1,57 @@
+
+require 'octokit'
+
+module ConfigLMM
+    module LMM
+        class GitHub < Framework::Plugin
+
+            def actionGitHubOrganizationRefresh(id, target, activeState, context, options)
+
+                client = Octokit::Client.new(:access_token => ENV['GITHUB_TOKEN'])
+                orgs = client.organizations.select { |org| org[:login] == target['Name'] }
+                if orgs.empty?
+                    prompt.say("Didn\'t find organization with name #{target['Name']}")
+                    prompt.say('You need to create it manually - https://github.com/organizations/plan')
+                    raise Framework::PluginPrerequisite.new('Organization must exist!')
+                end
+
+                raise "This shouldn't happen!" if orgs.length != 1
+
+                activeState.clear
+
+                orgs.first.each do |name, value|
+                    activeState[name.to_s] = value
+                end
+            end
+
+            def actionGitHubOrganizationDiff(id, target, activeState, context, options)
+                shouldMatch(id, 'Name', 'login', target, activeState)
+                shouldMatch(id, 'Description', 'description', target, activeState)
+            end
+
+            def actionGitHubOrganizationDeploy(id, target, activeState, context, options)
+                actionGitHubOrganizationDiff(id, target, activeState, context, options)
+                diff.each do |name, states|
+                    if name == 'Name'
+                        # TODO
+                    elsif name == 'Description'
+                        # TODO
+                    end
+                end
+                # TODO FIXME
+                raise 'Not implemented!'
+            end
+
+            def authenticate(actionMethod, target, activeState, context, options)
+                authToken = ENV['GITHUB_TOKEN']
+                if authToken.to_s.empty?
+                    prompt.say('Open https://github.com/settings/tokens and create a token!')
+                    prompt.say('Then set it\'s value to GITHUB_TOKEN as Environment Variable')
+                    raise Framework::PluginPrerequisite.new('Need GITHUB_TOKEN!')
+                end
+                true
+            end
+
+        end
+    end
+end

data/Plugins/Platforms/GoDaddy/GoDaddy.lmm.rb

@@ -0,0 +1,83 @@
+
+require 'http'
+require 'addressable/idna'
+
+module ConfigLMM
+    module LMM
+        class GoDaddy < Framework::DNS
+
+            API_DOMAIN = 'https://api.godaddy.com'
+            TEST_API_DOMAIN = 'https://api.ote-godaddy.com'
+            # Looks like GoDaddy is garbage and doesn't let people with few domains to use their API
+            USE_API = false
+
+            # TODO
+            # def actionGoDaddyDNSValidate(id, target, activeState, context, options)
+            #    We should check that target['DNS'] looks like valid config
+            # end
+
+            def actionGoDaddyDNSBuild(id, target, activeState, context, options)
+                outputFolder = options['output'] + '/' + id + '/'
+
+                template = ERB.new(File.read(__dir__ + '/zone.txt.erb'))
+
+                target['DNS'].each do |domain, data|
+                    config = { 'Domain' => domain, 'Records' => '' }
+                    data.each do |name, data|
+                        self.processDNS(domain, data).each do |type, records|
+                            records.each do |record|
+                                shortName = name
+                                config['Records'] += [shortName, record[:ttl], ' IN ', record[:type], record[:content]].join("\t") + "\n"
+                            end
+                        end
+                    end
+                    renderTemplate(template, config, outputFolder + domain + '.txt', options)
+                end
+            end
+
+            def actionGoDaddyDNSRefresh(id, target, activeState, context, options)
+                if USE_API
+                    http = HTTP.auth("sso-key #{ENV['GODADDY_SECRET']}")
+                    apiDomain = (options['dry'] || target['Test']) ? TEST_API_DOMAIN : API_DOMAIN
+
+                    target['DNS'].each do |domain, records|
+                        response = http.get("#{apiDomain}/v1/domains/#{Addressable::IDNA.to_ascii(domain)}/records")
+                        # TODO
+                    end
+
+                    # TODO
+                end
+            end
+
+            # TODO
+            # def actionGoDaddyDNSDiff(id, target, activeState, context, options)
+            # end
+
+            persistBuildDir
+
+            def actionGoDaddyDNSDeploy(id, target, activeState, context, options)
+                #actionGoDaddyDNSDiff(id, target, activeState, context, options)
+                if USE_API
+                    # TODO
+                else
+                    showManualDNSSteps(target, "Click on DNS tab and either import generated Zone file or add these records:") do |domain|
+                        prompt.say("Open https://dcc.godaddy.com/control/portfolio/#{domain}/settings", :color => :magenta)
+                    end
+                end
+            end
+
+            def authenticate(actionMethod, target, activeState, context, options)
+                if USE_API
+                    authSecret = ENV['GODADDY_SECRET']
+                    if authSecret.to_s.empty?
+                        prompt.say('Open https://developer.godaddy.com/keys and create API Key!')
+                        prompt.say('Then set "KEY:SECRET" to GODADDY_SECRET as Environment Variable')
+                        raise Framework::PluginPrerequisite.new('Need GODADDY_SECRET')
+                    end
+                end
+                true
+            end
+
+        end
+    end
+end

data/Plugins/Platforms/GoDaddy/zone.txt.erb

@@ -0,0 +1,13 @@
+
+$ORIGIN <%= config['Domain'] %>.
+
+; SOA Record
+@	3600	 IN 	SOA	ns23.domaincontrol.com.	dns.jomax.net. (
+					2024070803
+					28800
+					7200
+					604800
+					3600
+					) 
+
+<%= config['Records'] %>

data/Plugins/Platforms/porkbun.lmm.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'porkbun'
+
+module ConfigLMM
+    module LMM
+        class Porkbun < Framework::DNS
+
+            def actionPorkbunDNSValidate(id, target, activeState, context, options)
+                errors = []
+                if target['DNS'].to_h.empty?
+                    errors << id + ': DNS entries must be provided!'
+                end
+                errors
+            end
+
+            def actionPorkbunDNSRefresh(id, target, activeState, context, options)
+                result = ::Porkbun::Domain.list_all
+                if result[:status] == "SUCCESS"
+                    domainsInfo = result[:domains].map { |info| [ info[:domain], { :_meta_ => info } ] }.flatten
+                    activeState['DNS'] = Hash[*domainsInfo]
+                    activeState['DNS'].each do |domain, info|
+                        records = ::Porkbun::DNS.retrieve(domain)
+                        if records.instance_of?(::Porkbun::Error)
+                            if records.message.include?('Domain is not opted in to API access')
+                                prompt.warn("#{domain}: Skipping, #{records.message}")
+                            else
+                              raise Framework::PluginProcessError.new("Got error " + records.message)
+                            end
+                        else
+                            info[:_records_] = records.map { |record| record.to_h }
+                        end
+                    end
+                else
+                    raise Framework::PluginProcessError.new("Couldn't refresh " + id + "! Invalid PORKBUN_SECRET_API_KEY ?")
+                end
+            end
+
+            def actionPorkbunDNSDiff(id, target, activeState, context, options)
+                # TODO
+            end
+
+            def actionPorkbunDNSDeploy(id, target, activeState, context, options)
+                if target['DNS'].to_h.empty?
+                    raise Framework::PluginProcessError.new(id + ': DNS entries must be provided!')
+                end
+
+                actionPorkbunDNSDiff(id, target, activeState, context, options)
+
+                target['DNS'].each do |domain, info|
+                    presentRecords = ::Porkbun::DNS.retrieve(domain)
+                    if presentRecords.instance_of?(::Porkbun::Error)
+                        raise Framework::PluginProcessError.new("#{id}: #{domain} - #{result.message}")
+                    end
+                    activeState['DNS'] ||= {}
+                    activeState['DNS'][domain] ||= {}
+                    activeState['DNS'][domain][:_records_] = presentRecords.map { |record| record.to_h }
+
+                    info.each do |name, data|
+                        name = '' if name == '@'
+
+                        self.processDNS(domain, data).each do |type, records|
+                            records.each do |record|
+                                found = false
+                                remove = []
+                                presentRecords.each do |dns|
+                                    if (dns.name.downcase == ((name.empty? ? '' : name + '.') + domain).downcase)
+                                        # * Skip when content matches
+                                        # * When setting A/AAAA record we need to delete ALIAS
+                                        # * When setting ALIAS we need to delete A/AAAA record
+                                        if (dns.type == type && dns.content == record[:content])
+                                            found = true
+                                        elsif (type[0] == 'A' && dns.type == 'ALIAS') ||
+                                              (type == 'ALIAS' && dns.type == 'A') ||
+                                              (type == 'ALIAS' && dns.type == 'AAAA')
+                                            remove << dns
+                                        end
+                                    end
+                                end
+
+                                remove.each do |dns|
+                                    dns.delete
+                                    # TODO should also remove from activeState
+                                end
+
+                                if !found
+                                    prompt.say("Updating " + ((name.empty? || name == '@')? '' : name + '.') + domain)
+                                    result = ::Porkbun::DNS.create(domain: domain,
+                                                                   name: name,
+                                                                   type: record[:type],
+                                                                   content: record[:content],
+                                                                   ttl: record[:ttl]
+                                                                  )
+                                    if result.message.to_s.include?('unable')
+                                        raise Framework::PluginProcessError.new("#{id}: #{name} #{domain} - #{result.message}")
+                                    else
+                                      result = result.to_h
+                                      name = result[:name]
+                                      result[:name] = (result[:name].empty? ? '' : result[:name] + '.') + domain
+                                      name = '@' if name.empty?
+                                      activeState['DNS'][domain][name] = result
+                                    end
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+
+            def cleanup(configs, state, context, options)
+                # TODO
+            end
+
+            def authenticate(actionMethod, target, activeState, context, options)
+                if ENV['PORKBUN_API_KEY'].to_s.empty? || ENV['PORKBUN_SECRET_API_KEY'].to_s.empty?
+                    prompt.error('Set your porkbun API key to PORKBUN_API_KEY and PORKBUN_SECRET_API_KEY as Environment Variable')
+                    raise Framework::PluginPrerequisite.new('Need PORKBUN_API_KEY and PORKBUN_SECRET_API_KEY')
+                else
+                    result = ::Porkbun.ping
+                    if result[:status] != 'SUCCESS'
+                        raise Framework::PluginPrerequisite.new(result[:message])
+                    end
+                end
+                true
+            end
+
+        end
+    end
+end

data/Plugins/Platforms/porkbun_spec.rb

@@ -0,0 +1,110 @@
+
+require_relative('../../lib/ConfigLMM/commands/refresh')
+require_relative('../../lib/ConfigLMM/commands/deploy')
+require 'porkbun'
+require 'tty-logger'
+
+RSpec.describe 'Porkbun' do
+
+    let(:domains) {[
+                     {
+                         :domain => 'example.com'
+                     },
+                     {
+                         :domain => 'example.org'
+                     }
+                  ]}
+
+    let(:target) {
+                     {
+                         'Type' => 'PorkbunDNS',
+                         'DNS'  => {
+                                      'example.org' => { '@' => 'A=@me' }
+                                   }
+                     }
+                 }
+
+    it 'Refresh works' do
+        state = instance_double('ConfigLMM::State')
+        expect(ConfigLMM::State).to receive(:new).and_return(state)
+        expect(state).to receive(:create!)
+        expect(state).to receive(:item).twice.with('Porkbun').and_return({}) # Twice because we use it to validate result in test
+        expect(state).to receive(:save)
+
+        expect(::Porkbun).to receive(:ping).and_return({ :status => 'SUCCESS' })
+        expect(::Porkbun::Domain).to receive(:list_all).and_return({ :status => 'SUCCESS', :domains => domains })
+        expect(::Porkbun::DNS).to receive(:retrieve).with('example.com').and_return([{ :name => 'example.com' }])
+        expect(::Porkbun::DNS).to receive(:retrieve).with('example.org').and_return([{ :name => 'example.org',
+                                                                                       :content => 'example.com',
+                                                                                       :type => 'ALIAS'
+                                                                                     }])
+
+        ENV['PORKBUN_API_KEY'] = 'whatever'
+        ENV['PORKBUN_SECRET_API_KEY'] = 'whatever'
+        ConfigLMM::Commands::Refresh.new('whatever.yaml', { :level => :info }).processConfig({'Porkbun' => target}, {})
+
+        expect(state.item('Porkbun')).to include({
+            'DNS' => {
+                        'example.com' => {
+                          :_meta_ => { :domain => 'example.com' },
+                          :_records_=> [ { :name => 'example.com' } ]
+                        },
+                        'example.org' => {
+                          :_meta_=> { :domain=>'example.org' },
+                          :_records_=> [ {
+                                             :content => 'example.com',
+                                             :name => 'example.org',
+                                             :type => 'ALIAS'
+                                         }
+                                       ]
+                        }
+                    },
+            :Type => 'PorkbunDNS'
+        })
+    end
+
+    it 'Deploy works' do
+        state = instance_double('ConfigLMM::State')
+        expect(ConfigLMM::State).to receive(:new).and_return(state)
+        expect(state).to receive(:create!)
+        expect(state).to receive(:item).twice.with('Porkbun').and_return({}) # Twice because we use it to validate result in test
+        expect(state).to receive(:save)
+        expect(HTTP).to receive(:get).and_return(HTTP::Response.new(body: '127.0.0.1',
+                                                                    status: 200,
+                                                                    :version => '1.1',
+                                                                    request: nil))
+
+        expect(::Porkbun).to receive(:ping).and_return({ :status => 'SUCCESS' })
+
+        record = ::Porkbun::DNS.new({
+                                      name: '',
+                                      content: 'example.com',
+                                      type: 'ALIAS',
+                                      id: '12345',
+                                      domain: 'example.org'
+                                   })
+        expect(::Porkbun::DNS).to receive(:retrieve).with('example.org').and_return([record])
+        expect(::Porkbun::DNS).to receive(:create).with({
+                                                           :content => "127.0.0.1",
+                                                           :domain=>"example.org",
+                                                           :name=>"",
+                                                           :ttl=>600,
+                                                           :type=>"A"
+                                                       }).and_return(record)
+
+        ENV['PORKBUN_API_KEY'] = 'whatever'
+        ENV['PORKBUN_SECRET_API_KEY'] = 'whatever'
+        ConfigLMM::Commands::Deploy.new('whatever.yaml', { :level => :info }).processConfig({'Porkbun' => target}, {})
+
+        expect(state.item('Porkbun')['DNS']['example.org']).to include({ '@' => {
+            :content=>"example.com",
+            :domain => "example.org",
+            :id => "12345",
+            :name => "example.org",
+            :prio => nil,
+            :ttl => 600,
+            :type => "ALIAS"
+        }})
+    end
+
+end

data/Plugins/Services/DNS/AmberBit.lmm.rb

@@ -0,0 +1,14 @@
+
+module ConfigLMM
+    module LMM
+        class AmberBit < Framework::DNS
+
+            def actionAmberBitDNSDeploy(id, target, activeState, context, options)
+                showManualDNSSteps(target, "Click on Technical information and add these records:") do |domain|
+                    prompt.say("Open https://my.amberbit.eu/domain/list/ and under #{domain}", :color => :magenta)
+                end
+            end
+
+        end
+    end
+end

data/Plugins/Services/DNS/ArubaItDNS.lmm.rb

@@ -0,0 +1,14 @@
+
+module ConfigLMM
+    module LMM
+        class ArubaItDNS < Framework::DNS
+
+            def actionArubaItDNSDeploy(id, target, activeState, context, options)
+                showManualDNSSteps(target, "then click on 'DNS and Name Server Management' and add these records:") do |domain|
+                    prompt.say("Open https://admin.aruba.it/PannelloAdmin/LoginDomain.aspx and select #{domain}", :color => :magenta)
+                end
+            end
+
+        end
+    end
+end

data/Plugins/Services/DNS/NICLV.lmm.rb

@@ -0,0 +1,18 @@
+
+
+require 'http'
+require 'addressable/idna'
+
+module ConfigLMM
+    module LMM
+        class NICLV < Framework::DNS
+
+            def actionNICLVDNSDeploy(id, target, activeState, context, options)
+                showManualDNSSteps(target, "and add these records:") do |domain|
+                    prompt.say("Open https://www.nic.lv/client/topview/edit_domain?dname=#{domain}", :color => :magenta)
+                end
+            end
+
+        end
+    end
+end