api_deploy 0.1.0

data/lib/bitbucket.rb

@@ -0,0 +1,68 @@
+class Bitbucket
+  include API
+  LIMIT=1000.to_s
+
+  HOOK_EXCLUSIONS = ['WSC','CM','YOMS']
+
+  def initialize
+    create_api( ConfigStore.bitbucket )
+  end
+
+  def projects
+    @projects ||= Project.get_all(self)
+  end
+
+  def set_master_branch_protected_on_all_projects
+    projects.map do |project|
+      project.repositories.map do |r|
+        r.set_master_branch_protected unless r.master_branch_protected?
+      end
+    end
+  end
+
+  def set_hook_status_on_all_projects(key,status,settings=nil)
+    projects.map do |project|
+      next if HOOK_EXCLUSIONS.include?(project.key)
+      project.set_hook_status(key, status, settings)
+    end
+  end
+
+  def remove_hooks_on_exclusions
+    projects.select {|p| HOOK_EXCLUSIONS.include? p.key }.each do |project|
+      [
+        'org.christiangalsterer.stash-filehooks-plugin:filesize-hook',
+        "org.christiangalsterer.stash-filehooks-plugin:filename-hook",
+      ].each do |key|
+        project.set_hook_status(key, false)
+      end
+    end
+  end
+
+  def apply_restrictions
+    set_hook_status_on_all_projects(
+      "org.christiangalsterer.stash-filehooks-plugin:filesize-hook",
+      true,
+      {
+        "pattern-1"=>".*",
+        "size-1"=>"10485760",
+        "pattern-exclude-1"=>"",
+        "pattern-branches-1"=>""
+      }.to_json
+    )
+
+    set_hook_status_on_all_projects(
+      "org.christiangalsterer.stash-filehooks-plugin:filename-hook",
+      false,
+      {
+        "pattern"=>"\\.(h26.?|mp.?.?|avi|webm|flv|tar(\\..?.?.?)?|zip|7z|rar|exe|msi|rpm|deb)$",
+        "pattern-exclude"=>"",
+        "pattern-branches"=>""
+      }.to_json
+    )
+
+    set_master_branch_protected_on_all_projects
+
+    # cleanup TRAIN project
+    projects.detect {|p| p.key == 'TRAIN'}.move_all_repos_to_project('TOLD')
+  end
+end

data/lib/bitbucket/project.rb

@@ -0,0 +1,34 @@
+class Project
+  include API
+  LIMIT=1000.to_s
+
+  def self.get_all(server)
+    data = server.request(:get, "rest/api/1.0/projects?limit=#{LIMIT}")
+    data['values'].map {|p| new(server,p) }
+  end
+
+  attr_reader :name, :key
+
+  def initialize(server,data)
+    @bb = server
+    @name = data['name']
+    @key = data['key']
+  end
+
+  def repositories
+    @repositories ||= Repository.get_all(@bb,key)
+  end
+
+  def move_all_repos_to_project(new_project)
+    repositories.each do |r|
+      r.move_repo_to_project(new_project)
+    end
+  end
+
+  def set_hook_status(key,status,settings=nil)
+    repositories.each do |r|
+      r.set_hook_settings(key, settings) if status && settings
+      r.set_hook_status(key, status)
+    end
+  end
+end

data/lib/bitbucket/repository.rb

@@ -0,0 +1,66 @@
+class Repository
+  include API
+  LIMIT=1000.to_s
+
+  def self.get_all(bb,project)
+    data = bb.request(:get, "rest/api/1.0/projects/#{project}/repos/?limit=#{LIMIT}")
+    data['values'].map {|p| new(bb,p) }
+  end
+
+  attr_reader :bb, :name, :project
+
+  def initialize(server,data)
+    @bb = server
+    @name = data['slug']
+    @project = data['project']['key']
+  end
+
+  def branch_permissions
+    bb.request(:get, "rest/branch-permissions/2.0/projects/#{project}/repos/#{name}/restrictions")['values']
+  end
+
+  def master_branch_protected?
+    !! branch_permissions.detect do |c|
+      c["type"] == 'fast-forward-only' && c["matcher"]["id"] == 'refs/heads/master'
+    end
+  end
+
+  def set_master_branch_protected
+    perm = {
+      "type"=>"fast-forward-only",
+      "matcher"=>
+      {"id"=>"refs/heads/master",
+       "displayId"=>"master",
+       "type"=>{"id"=>"BRANCH", "name"=>"Branch"},
+       "active"=>true},
+       "users"=>[],
+       "groups"=>[]
+    }.to_json
+    bb.request(:post, "rest/branch-permissions/2.0/projects/#{project}/repos/#{name}/restrictions", perm)
+  end
+
+  def move_repo_to_project(new_project)
+    bb.request(:post, "/rest/api/1.0/projects/#{project}/repos/#{name}",{project: {key: new_project}}.to_json)
+    bb.request(:delete, "/rest/api/1.0/projects/#{project}/repos/#{name}")
+  end
+
+  def hooks
+    bb.request(:get, "rest/api/1.0/projects/#{project}/repos/#{name}/settings/hooks")
+  end
+
+  def set_hook_status(key, status)
+    if status
+      bb.request(:put, "rest/api/1.0/projects/#{project}/repos/#{name}/settings/hooks/#{key}/enabled")
+    else
+      bb.request(:delete, "rest/api/1.0/projects/#{project}/repos/#{name}/settings/hooks/#{key}/enabled")
+    end
+  end
+
+  def hook_settings(key)
+    bb.request(:get, "rest/api/1.0/projects/#{project}/repos/#{name}/settings/hooks/#{key}/settings")
+  end
+
+  def set_hook_settings(key, settings)
+    bb.request(:put, "rest/api/1.0/projects/#{project}/repos/#{name}/settings/hooks/#{key}/settings", settings)
+  end
+end

data/lib/config_store.rb

@@ -0,0 +1,40 @@
+class ConfigStore
+  @@defaults_path = File.join(File.dirname(__FILE__),'../config/defaults.json')
+  @@overrides_path = File.expand_path('~/.config/api_deploy_overrides.json')
+
+  def self.defaults_path
+    @@defaults_path
+  end
+
+  def self.defaults_path=(path)
+    @@defaults_path = path
+  end
+
+  def self.overrides_path
+    @@overrides_path
+  end
+
+  def self.overrides_path=(path)
+    @@overrides_path = path
+  end
+
+  def self.load_config
+    warn "ConfigStoreuration overrides file not present at #{overrides_path}" unless File.exists?(overrides_path)
+    defaults = Hashie::Mash.new(JSON.parse(File.read(defaults_path))) if File.exists?(defaults_path)
+    overrides = JSON.parse(File.read(overrides_path)) if File.exists?(overrides_path)
+    defaults.deep_merge(overrides || {})
+  end
+
+  class << self
+    def teamcity; @@ConfigStore.teamcity; end
+    def artifactory; @@ConfigStore.artifactory; end
+    def octopus; @@ConfigStore.octopus; end
+    def bitbucket; @@ConfigStore.bitbucket; end
+  end
+
+  def self.set_config
+    @@ConfigStore = self.load_config
+  end
+
+  self.set_config
+end

data/lib/github.rb

@@ -0,0 +1,13 @@
+class GithubApi
+  attr_reader :api
+
+  ORG = 'YTech'
+
+
+  def initialize
+    @api = Github.new(
+      basic_auth: "#{ENV['GITHUB_API_USER']}:#{ENV['GITHUB_API_PASS']}",
+      org: ORG
+    )
+  end
+end

data/lib/ldap.rb

@@ -0,0 +1,115 @@
+class LdapApi
+
+  YOOX = {
+    name: 'YOOX',
+    host: 'ydcrootblq.yoox.net',
+    base: 'dc=yoox,dc=net',
+    port: 389,
+    user: ENV['YOOX_BIND_USER'],
+    pass: ENV['YOOX_BIND_PASS'],
+  }
+  NAP = {
+    name: 'LONDON',
+    host: 'RODC02-PR-IMO.london.net-a-porter.com',
+    base: 'dc=london,dc=net-a-porter,dc=com',
+    port: 389,
+    user: ENV['NAP_BIND_USER'],
+    pass: ENV['NAP_BIND_PASS'],
+  }
+
+  DOMAINS = [ YOOX, NAP ]
+
+  def domains
+    domain_structs = DOMAINS.map do |domain|
+      d = OpenStruct.new(
+        name: domain[:name],
+        user: domain[:user],
+        pass: domain[:pass],
+        ldap: Net::LDAP.new(
+          host: domain[:host],
+          port: domain[:port],
+          base: domain[:base],
+          auth: {
+            method: :simple,
+            username: domain[:user],
+            password: domain[:pass],
+          },
+        )
+      )
+      raise "BIND ERROR: #{domain}" unless d.ldap.bind
+      d
+    end
+  end
+
+  def auth?(username, password)
+    domains.each do |domain|
+      domain.ldap.authenticate domain.name + "\\" + username, password
+      return true if domain.ldap.bind
+    end
+    return false
+  end
+
+  def groups(name)
+    filter = Net::LDAP::Filter.eq("sAMAccountName", name)
+    results = []
+    domains.map do |domain|
+      domain.ldap.search(filter: filter) do |entry|
+        results << entry.memberof.map {|e| e.sub(/^CN=/,'').sub(/,.*$/,'') }
+      end
+      domain.ldap.get_operation_result
+    end
+    results.flatten
+  end
+
+  def user(name)
+    filter = Net::LDAP::Filter.eq("sAMAccountName", name)
+    results = []
+    domains.map do |domain|
+      domain.ldap.search(filter: filter) do |entry|
+        results << entry
+      end
+      domain.ldap.get_operation_result
+    end
+    results.flatten
+  end
+
+  def group(name)
+    filter = Net::LDAP::Filter.eq("cn", name)
+    results = []
+    domains.map do |domain|
+      domain.ldap.search(filter: filter) do |entry|
+        results << entry
+      end
+      domain.ldap.get_operation_result
+    end
+    results.flatten
+  end
+
+  def in_group?(name, group)
+    groups(name).include?(group)
+  end
+
+  def users_in_group(group)
+    filter = Net::LDAP::Filter.eq("cn", group)
+    results = []
+    domains.map do |domain|
+      domain.ldap.search(filter: filter) do |entry|
+        results << entry.member.map {|e| user_from_name(e.sub(/^CN=/,'').sub(/,.*$/,'')) }
+      end
+      domain.ldap.get_operation_result
+    end
+    results.flatten
+  end
+
+  def user_from_name(name)
+    filter = Net::LDAP::Filter.eq("cn", name)
+    results = []
+    domains.map do |domain|
+      domain.ldap.search(filter: filter) do |entry|
+        results << entry[:samaccountname]
+      end
+      domain.ldap.get_operation_result
+    end
+    results.flatten
+  end
+end

data/lib/libraries.rb

@@ -0,0 +1,10 @@
+require 'artifactory'
+require 'faraday'
+require 'json'
+require 'hashie'
+require 'logging'
+require 'require_all'
+require 'net/ldap'
+require 'github_api'
+
+require_rel '../lib'

data/lib/log.rb

@@ -0,0 +1,13 @@
+class Log
+  class << self
+    def logger
+      @logger ||= ::Logging.logger(STDOUT)
+      @logger.level = ENV.fetch("LOG_LEVEL", "warn").to_sym
+      @logger
+    end
+    def warn(m); logger.warn(m); end
+    def info(m); logger.info(m); end
+    def debug(m); logger.debug(m); end
+    def level=(l); logger.level = l; end
+  end
+end

data/lib/octopus_api.rb

@@ -0,0 +1,56 @@
+class OctopusApi
+  include API
+
+  RESOURCE_TYPES = ['Environments','Projects','ProjectGroups','NugetFeeds','LibraryVariableSets','Machines','Lifecycles','Users','Releases','Deployments']
+
+
+  def initialize
+    create_api(ConfigStore.octopus)
+  end
+
+  def create_resource(type, query)
+    check_type type
+    request(:post, "/#{type}", query)
+  end
+
+  def remove_resource(type, id)
+    check_type type
+    request(:delete, "/#{type}/#{id}")
+  end
+
+  def get_resource(type)
+    check_type type
+    return request(:get, "/#{type}/all")
+  end
+
+  def resource_exists?(type, name)
+    resource = get_resource_by_type_and_name(type, name)
+    return (resource && resource != [])
+  end
+
+  def get_resource_by_type_and_name(type, name = nil)
+    resources = get_resource(type)
+    if name && name != ''
+      filter = [*name].join("|")
+
+      filtered_resources = resources.select do |resource|
+        resource['Name'] =~ /#{filter}/
+      end
+
+      if filtered_resources.any?
+        Log.info "#{filtered_resources.count} resources found with filter #{filter}"
+        filtered_resources
+      else
+        Log.info "No #{type} found with filter #{filter}"
+        return nil
+      end
+    else
+      resources
+    end
+  end
+
+  def check_type(type)
+    raise NameError, "Invalid resource type supplied: '#{type}'" unless RESOURCE_TYPES.include? type
+  end
+end
+

data/lib/teamcity_api.rb

@@ -0,0 +1,40 @@
+class TeamcityApi
+  include API
+
+  def initialize
+    create_api( ConfigStore.teamcity )
+  end
+
+  def build_queue
+    request(:get, 'buildQueue')
+  end
+
+  def create_build(build_config_id, properties={})
+    properties_string = ""
+    properties.each_pair do |k,v|
+      properties_string << "<property name='#{k}' value='#{v}'/>\n"
+    end
+    data = "
+      <build>
+        <buildType id='#{build_config_id}'/>
+      <properties>
+        #{properties_string}
+      </properties>
+      </build>
+    "
+    request(:post, 'buildQueue', data, "xml")
+  end
+
+  def set_project_parameter(project_id,parameter,value)
+    request(:put, "projects/#{project_id}/parameters/#{parameter}", value, "text")
+  end
+
+  def projects(parent_id=nil)
+    list = Nokogiri::XML.parse(request(:get, 'projects').body)
+    if parent_id
+      (list.xpath '//project').select {|e| e.attributes['parentProjectId'].to_s ==  parent_id}
+    else
+      list
+    end
+  end
+end