mooset 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c1dd100f51b3643d324c7003d9a7ee5be2c2cf0
-  data.tar.gz: 050188451cc9fc0a22c32c86036d3d55a665ea38
+  metadata.gz: 006161edeef876748ef7483011278a0a26f4098d
+  data.tar.gz: d93d1a0d851946612246a14b03e694a8743ed29c
 SHA512:
-  metadata.gz: 3b01c6cf1a52ba47895c6e2f01eb3b31bc60fc4340b9e6d9078830b26121f10eb74a0e93e06c0337cd215519d78e41d509e248425c0409af472c6339c8b2f139
-  data.tar.gz: 681efd27a6ed58b68b3fd352612854367c9bb54c54cdc9e4e3b3a9c7d8414e8f4b38c0de34aafdac718895998e4a09ac385ff7f1eb1b6b95e5e35d45dd783158
+  metadata.gz: 7077ad440a847771fe16c8b3086b7c0e8d2a5dfff7d464ec96cb7b44279fc94ffc8fec43cf28e559bb127b659ec5cc1561db8a14470086f6824023ba59ea4fc9
+  data.tar.gz: e69db56d141bf63fbcdfe8c77df1b1cae798e67e9088104d4b6d3786c373456251558238a9ecd8e4d2de571dc7e8b0c2b3aa1dcb8e0f77b8484d6b7bfe59afa5

data/config/sample

@@ -1,6 +1,6 @@
 # vi:syntax=ruby
 
-define :origin, :null, {
+define :origin, :ldap, {
   host: 'localhost',
   port: 389,
   bind_dn: 'CN=user,OU=users,DC=domain,DC=com',
@@ -8,11 +8,18 @@ define :origin, :null, {
   treebase: 'DC=domain,DC=com'
 }
 
+define :ldap_encrypted, :ldap, {
+  host: 'localhost',
+  port: 636,
+  bind_dn: 'CN=user,OU=users,DC=domain,DC=com',
+  bind_password: '',
+  treebase: 'DC=domain,DC=com',
+  encryption: :simple_tls
+}
+
 define :gitlab_dev, :gitlab, {
   endpoint: 'http://gitlab',
   private_token: ''
 }
 
-define :out, :console_logger
-
 synchronize_users from: :origin, to: :output, query: '(&(memberof=CN=Users,DC=domain,DC=com)(!(useraccountcontrol:1.2.840.113556.1.4.803:=2)))'

data/lib/mooset/application.rb

@@ -1,37 +1,54 @@
 require 'optparse'
+require 'irb'
+require 'logger'
 
 module Mooset
   class Application
-    attr_accessor :config_filename
+    attr_accessor :config_filename, :interactive, :logfile
 
-    def define(endpoint_name, factory, *args)
-      Mooset.define_singleton_method(endpoint_name) do
-        Mooset::Endpoints::Endpoint.create(factory, endpoint_name, *args)
-      end
+    def define(endpoint_name, factory, opts = {})
+      opts[:endpoint_name] = endpoint_name
+      opts[:logger] = logger
+
+      endpoints[endpoint_name] = Mooset::Endpoints::Endpoint.create(factory, opts)
+    end
+
+    def endpoints
+      @endpoints ||= {}
+    end
+
+    def logger
+      @logger ||= begin
+                    l = ::Logger.new(logfile || STDOUT)
+                    l.level = ::Logger::WARN
+                    l
+                  end
     end
 
     def instances
       @instances ||= {}
     end
 
-    def synchronize_users(from:, to:, **opts)
-      connections << { from: from, to: to, opts: opts }
+    def synchronize_group(from:, to:, **opts)
+      operations << Mooset::SynchronizeGroups.new(endpoints[from], endpoints[to], opts)
     end
 
-    def connections
-      @connection ||= []
+    def operations
+      @operations ||= []
     end
 
     def run!
-      connections.each do |event|
-        from = instances[event[:from]]
-        to = instances[event[:to]]
-        opts = event[:opts]
-
-        Mooset::SynchronizeUsers.call(from, to, opts)
+      operations.each do |operation|
+        operation.call
       end
     end
 
+    def start_irb
+      $app = self
+
+      IRB.start
+    end
+
     def read_config
       instance_eval File.read(config_filename), config_filename
     end
@@ -45,12 +62,22 @@ module Mooset
 
       OptionParser.new do |opts|
         opts.banner = "Usage: #{$0} [options]"
+        opts.on("-f", "--logfile FILE", "Logfile", s.method(:logfile=))
+        opts.on("-v", "--verbose", "Verbose") do |x|
+          s.logger.level = ::Logger::INFO
+        end
+
         opts.on("-c", "--config FILE", "Config file", s.method(:config_filename=))
+        opts.on("-i", "--interactive", "Run in interactive mode", s.method(:interactive=))
         opts.parse!(argv)
       end
 
-      s.read_config
-      s.run!
+      if s.config_filename
+        s.read_config
+        s.run! unless s.interactive
+      end
+
+      s.start_irb if s.interactive
     end
 
   end

data/lib/mooset/endpoints/endpoint.rb

@@ -5,13 +5,8 @@ module Mooset
     class Endpoint
       include Virtus.model
 
-      attr_reader :endpoint_name
-
-      def initialize(endpoint_name, *args)
-        @endpoint_name = endpoint_name
-
-        super(*args)
-      end
+      attribute :logger
+      attribute :endpoint_name
 
       def self.inherited(klass)
         super
@@ -32,8 +27,26 @@ module Mooset
           downcase
       end
 
-      def self.create(name, endpoint_name, *args)
-        descendants[name].new(endpoint_name, *args)
+      def self.create(name, opts = {})
+        descendants[name].new(opts)
+      end
+
+      def self.resources
+        @resources ||= []
+      end
+
+      def self.resource(name, &block)
+        resources << name
+
+        define_method(name) do
+          r = instance_variable_get("@#{name}")
+          if r.nil?
+            r = instance_eval(&block)
+            instance_variable_set("@#{name}", r)
+          end
+          r
+        end
+
       end
     end
   end

data/lib/mooset/endpoints/findable.rb

@@ -0,0 +1,62 @@
+module Mooset
+  module Endpoints
+    module Findable
+      module ClassMethods
+        def import(name, &block)
+          define_method(import_method_name(name), &block)
+        end
+
+        def finder(name, &block)
+          define_method(finder_method_name(name), &block)
+        end
+
+        def finder_method_name(name)
+          "find_by_#{name}"
+        end
+
+        def import_method_name(name)
+          "import_from_#{name}"
+        end
+      end
+
+      module InstanceMethods
+        def import(object)
+          method = self.class.import_method_name(object.provider)
+
+          public_send(method, object)
+        end
+
+        def find_from_object(object, *args)
+          finder = object.finders.find { |x| respond_to? self.class.finder_method_name(x) }
+
+          if finder && object[finder]
+            public_send(self.class.finder_method_name(finder), object[finder], *args)
+          end
+        end
+
+        def find_from_hash(hash)
+          key, value = hash.find { |(k, _)| respond_to? self.class.finder_method_name(k) }
+
+          args = hash.tap do |h|
+            h.delete(key)
+          end
+
+          if key && value
+            public_send(self.class.finder_method_name(key), value, args)
+          end
+        end
+
+        def find(opts, *args)
+          return find_from_hash(opts, *args) if opts.is_a? Hash
+
+          find_from_object(opts, args)
+        end
+      end
+
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end

data/lib/mooset/endpoints/gitlab/group.rb

@@ -8,14 +8,18 @@ module Mooset
         MASTER    = 40
         OWNER     = 50
 
+        attribute :gitlab_id
         attribute :path
         attribute :owner_id
         attribute :provider, String, default: "gitlab"
 
-        def self.build(endpoint_name, group)
+        finders [:gitlab_id, :name]
+
+        def self.build(endpoint, group)
           new(
-            endpoint_name: endpoint_name,
+            endpoint: endpoint,
             id: group.id,
+            gitlab_id: group.id,
             name: group.name,
             path: group.path,
             owner_id: group.owner_id
@@ -23,10 +27,12 @@ module Mooset
         end
 
         def members
-          endpoint.users.memberof(id)
+          @members ||= endpoint.users.group_members(id).to_a
         end
 
         def <<(user)
+          @logger.info "add_group_member #{id} #{user.id} DEVELOPER"
+
           endpoint.groups.add_group_member(id, user.id, DEVELOPER)
         end
       end

data/lib/mooset/endpoints/gitlab/group_search.rb

@@ -2,6 +2,9 @@ module Mooset
   module Endpoints
     class Gitlab
       class GroupSearch
+        include Paginate
+        include Findable
+
         attr_reader :endpoint
 
         def initialize(endpoint)
@@ -9,39 +12,39 @@ module Mooset
         end
 
         def all
-          page = 1
-          objects = []
+          return to_enum(:all) unless block_given?
 
-          while (o = connection.groups(page: page)).length > 0 do
-            objects += o
-            page += 1
-          end
+          paginate ->(page){ connection.groups(page: page) }, ->(object){ yield Group.build(endpoint, object) }
+        end
 
-          objects.collect do |object|
-            Group.build(endpoint.endpoint_name, object)
-          end
+        finder :all do |_, opts = {}|
+          all
         end
 
-        def find(id)
-          Group.build(endpoint.endpoint_name, connection.group(id))
+        finder :id do |id, opts = {}|
+          Group.build(endpoint, connection.group(id))
         end
 
-        def members(id)
-          page = 1
-          objects = []
+        finder :gitlab_id do |gitlab_id, opts = {}|
+          find(id: gitlab_id)
+        end
 
-          while (o = connection.group_members(id, page: page)).length > 0 do
-            objects += o
-            page += 1
-          end
+        finder :name do |name, opts = {}|
+          all.find { |x| x.name == name }
+        end
+
+        import :ldap do |group, opts = {}|
+          create(group.name, group.name.gsub(/( )/, '_').downcase)
+        end
+
+        def members(id)
+          return to_enum(:members, id) unless block_given?
 
-          objects.collect do |object|
-            User.build(endpoint.endpoint_name, object)
-          end
+          paginate ->(page){ connection.group_members(id, page: page) }, ->(object){ yield User.build(endpoint, object) }
         end
 
         def create(name, path)
-          Group.build(endpoint.endpoint_name, connection.create_group(name, path))
+          Group.build(endpoint, connection.create_group(name, path))
         end
 
         def add_group_member(team_id, user_id, access_level = 50)

data/lib/mooset/endpoints/gitlab/paginate.rb

@@ -0,0 +1,18 @@
+module Mooset
+  module Endpoints
+    class Gitlab
+      module Paginate
+        def paginate(lookup, builder)
+          page = 1
+
+          while (o = lookup.call(page)).length > 0 do
+            o.each do |oo|
+              builder.call(oo)
+            end
+            page += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mooset/endpoints/gitlab/user.rb

@@ -2,21 +2,35 @@ module Mooset
   module Endpoints
     class Gitlab
       class User < Models::User
+        attribute :gitlab_id
         attribute :state
         attribute :access_level
         attribute :provider, String, default: "gitlab"
+        attribute :ldap_id, String
 
-        def self.build(endpoint_name, user)
+        finders [:gitlab_id, :ldap_id, :email, :username]
+
+        def self.build(endpoint, user)
           self.new(
-            endpoint_name: endpoint_name,
+            endpoint: endpoint,
             id: user.id,
+            gitlab_id: user.id,
             username: user.username,
             full_name: user.name,
             state: user.state,
             email: user.email,
-            access_level: user.access_level
+            access_level: user.access_level,
+            ldap_id: Optional.new(user).identities.within do |identities|
+              identity_from(Many.new(identities)).values.first
+            end.value,
           )
         end
+
+        def self.identity_from(identities)
+          identities.within do |o|
+            o["extern_uid"] if o["provider"] == 'ldap'
+          end
+        end
       end
     end
   end

data/lib/mooset/endpoints/gitlab/user_search.rb

@@ -2,6 +2,9 @@ module Mooset
   module Endpoints
     class Gitlab
       class UserSearch
+        include Paginate
+        include Findable
+
         attr_reader :endpoint
 
         def initialize(endpoint)
@@ -9,35 +12,52 @@ module Mooset
         end
 
         def all
-          page = 1
-          objects = []
+          return to_enum(:all) unless block_given?
+
+          paginate ->(page){ connection.users(page: page) }, ->(object){ yield User.build(endpoint, object) }
+        end
 
-          while (o = connection.users(page: page)).length > 0 do
-            objects += o
-            page += 1
-          end
+        def alll
+          @alll ||= all.to_a
+        end
 
-          objects.collect do |object|
-            User.build(endpoint.endpoint_name, object)
-          end
+        finder :id do |id, opts = {}|
+          User.build(endpoint, connection.user(id))
         end
 
-        def find(id)
-          User.build(endpoint.endpoint_name, connection.user(id))
+        finder :gitlab_id do |gitlab_id, opts = {}|
+          find(id: gitlab_id)
         end
 
-        def memberof(id)
-          page = 1
-          objects = []
+        finder :username do |username, opts = {}|
+          alll.find { |x| x.username == username }
+        end
+
+        finder :email do |email, opts = {}|
+          alll.find { |x| x.email == email }
+        end
+
+        finder :dn do |dn, opts = {}|
+          alll.find { |x| x.ldap_id == dn }
+        end
+
+        import :ldap do |user|
+          create(user.email, SecureRandom.hex(8), {
+            name: user.full_name,
+            username: user.username,
+            extern_uid: user.dn,
+            provider: 'ldap',
+          })
+        end
+
+        def create(email, password, opts = {})
+          User.build(endpoint, connection.create_user(email, password, opts))
+        end
 
-          while (o = connection.group_members(id, page: page)).length > 0 do
-            objects += o
-            page += 1
-          end
+        def group_members(id, &block)
+          return to_enum(:group_members, id) unless block_given?
 
-          objects.collect do |object|
-            User.build(endpoint.endpoint_name, object)
-          end
+          paginate ->(page){ connection.group_members(id, page: page) }, ->(object){ block.call User.build(endpoint, object) }
         end
 
         private

data/lib/mooset/endpoints/gitlab.rb

@@ -13,16 +13,12 @@ module Mooset
         })
       }
 
-      attribute :storage, Object, default: Proc.new {
-        Storage::Memory.new(name)
-      }
-
-      def users
-        @users ||= UserSearch.new(self)
+      resource :users do
+        UserSearch.new(self)
       end
 
-      def groups
-        @groups ||= GroupSearch.new(self)
+      resource :groups do
+        GroupSearch.new(self)
       end
 
       def write(user)

data/lib/mooset/endpoints/ldap/group.rb

@@ -2,24 +2,22 @@ module Mooset
   module Endpoints
     class Ldap
       class Group < Models::Group
+        attribute :dn, String
         attribute :provider, String, default: "ldap"
+        finders [:dn, :name]
 
-        def self.build(endpoint_name, params)
+        def self.build(endpoint, params)
           group = Optional.new(params)
           new(
-            endpoint_name: endpoint_name,
-            id: group[:dn].value,
-            name: group[:cn].first.value,
-            member: group[:member].within do |users|
-              users_from(endpoint_name, Many.new(users)).values
-            end.value,
+            endpoint: endpoint,
+            id: group[:dn].first.value,
+            dn: group[:dn].first.value,
+            name: group[:cn].first.value
           )
         end
 
-        def self.users_from(endpoint_name, users)
-          users.within do |user|
-            Ldap::User.build(endpoint_name, id: user)
-          end
+        def members
+          endpoint.users.find(memberof: id)
         end
       end
     end

data/lib/mooset/endpoints/ldap/ldap_search.rb

@@ -0,0 +1,56 @@
+module Mooset
+  module Endpoints
+    class Ldap
+      class LdapSearch
+        include Findable
+        GROUP_FILTER = "(objectClass=group)"
+
+        attr_reader :endpoint
+
+        def initialize(endpoint, default_search)
+          @endpoint = endpoint
+          @default_search = default_search
+        end
+
+        finder :dn do |dn, base: nil|
+          s = base.nil? ? @default_search : dn
+          b = base.nil? ? dn : base
+
+          query(s, base: b)
+        end
+
+        finder :name do |name, opts = {}|
+          query("(&(objectclass=group)(cn=#{name}))")
+        end
+
+        finder :memberof do |dn, base: endpoint.treebase|
+          query("(&(objectclass=person)(memberof=#{dn})(!(useraccountcontrol:1.2.840.113556.1.4.803:=2)))", base: base)
+        end
+
+        def query(filter = @default_search, base: endpoint.treebase)
+          return to_enum(:query, filter, base: base) unless block_given?
+
+          connection.search(base: base, filter: filter) do |object|
+            if object[:objectclass] && object[:objectclass].include?("group")
+              r = Group.build(endpoint, object)
+            elsif object[:objectclass] && object[:objectclass].include?("user")
+              r = User.build(endpoint, object)
+            elsif object[:objectclass] && object[:objectclass].include?("organizationalUnit")
+              r = Ou.build(endpoint, object)
+            else
+              raise "Unknown objectclass #{object[:objectclass]}"
+            end
+
+            yield r
+          end
+        end
+
+        private
+
+        def connection
+          @endpoint.connection
+        end
+      end
+    end
+  end
+end

data/lib/mooset/endpoints/ldap/ou.rb

@@ -0,0 +1,12 @@
+module Mooset
+  module Endpoints
+    class Ldap
+      class Ou < Group
+        def members
+          endpoint.users.query('(&(objectClass=user)(!(useraccountcontrol:1.2.840.113556.1.4.803:=2)))', base: dn)
+        end
+      end
+    end
+  end
+end
+

data/lib/mooset/endpoints/ldap/user.rb

@@ -41,26 +41,21 @@ module Mooset
       end
 
       class User < Models::User
-        attribute :provider, String, default: "ldap"
+        finders [:dn, :username, :email]
 
-        def self.groups_from(endpoint_name, groups)
-          groups.within do |group|
-            Ldap::Group.build(endpoint_name, id: group)
-          end
-        end
+        attribute :provider, String, default: "ldap"
+        attribute :dn, String
 
-        def self.build(endpoint_name, params)
+        def self.build(endpoint, params)
           user = Optional.new(params)
 
           self.new(
-            endpoint_name: endpoint_name,
-            id: user[:dn].value,
-            dn: user[:dn].value,
+            endpoint: endpoint,
+            id: user[:dn].first.value,
+            dn: user[:dn].first.value,
             email: user[:mail].first.value,
             full_name: user[:cn].first.value,
-            username: user[:sAMAccountName].value,
-            memberof: user[:memberof].within { |groups| groups_from(endpoint_name, Many.new(groups)).values }.value,
-            useraccountcontrol: AccountControl.decode(user[:useraccountcontrol][0].to_i),
+            username: user[:sAMAccountName].first.value,
           )
         end
       end

data/lib/mooset/endpoints/ldap.rb

@@ -11,38 +11,26 @@ module Mooset
       attribute :bind_dn, String
       attribute :bind_password, String
       attribute :treebase, String
+      attribute :encryption, Symbol
       attribute :connection, Object, default: Proc.new { |ldap, attribute|
         connection = Net::LDAP.new
         connection.host = ldap.host
         connection.port = ldap.port
+        connection.encryption(ldap.encryption)
         connection.auth ldap.bind_dn, ldap.bind_password
         connection
       }
 
-      attribute :storage, Object, default: Proc.new { Storage::Memory.new(name)  }
-
       def write(*user)
         raise "Read only endpoint"
       end
 
-      def users(query = USER_FILTER)
-        UserSearch.new(self)
-      end
-
-      def find(dn)
-        Many.new(query("(objectClass=*)", base: dn)).within do |data|
-          if data[:objectclass] && data[:objectclass].include?("group")
-            Group.build(connection, data)
-          elsif data[:objectclass] && data[:objectclass].include?("user")
-            User.build(connection, data)
-          else
-            raise "Unknown objectclass"
-          end
-        end.values.first
+      resource :users do
+        LdapSearch.new(self, "(objectClass=person)")
       end
 
-      def groups(query = GROUP_FILTER)
-        GroupSearch.new(self)
+      resource :groups do
+        LdapSearch.new(self, "(|(objectClass=group)(objectClass=organizationalUnit))")
       end
     end
   end

data/lib/mooset/endpoints/null.rb

@@ -1,12 +1,54 @@
 module Mooset
   module Endpoints
     class Null < Endpoint
-      def users(query)
-        [OpenStruct.new]
+      class U
+        #include Findable
+
+        def create(u)
+          Models::User.new(id: u.id, username: u.username, email: u.email)
+        end
+
+        def import(from, *args)
+          @logger.info(from, *args)
+        end
+
+        #import :ldap do |u|
+          #create(u)
+        #end
+      end
+
+      class G
+        include Findable
+
+        def create(u)
+          model = Models::Group.new(id: u.id, name: u.name)
+          model.send :define_singleton_method, :'<<' do |other|
+            @logger.info "#{self.id} << #{other.id}"
+          end
+
+          model
+        end
+
+        import :gitlab do |o|
+          logger.info o
+        end
+
+        import :ldap do |gr|
+          g = create(gr)
+          g.send :define_singleton_method, :members do
+            []
+          end
+          g
+        end
+
+      end
+
+      resource :users do
+        U.new
       end
 
-      def groups(query)
-        []
+      resource :groups do
+        G.new
       end
     end
   end

data/lib/mooset/endpoints.rb

@@ -1,15 +1,16 @@
 require 'mooset/endpoints/endpoint'
+require 'mooset/endpoints/findable'
 require 'mooset/endpoints/gitlab'
 require 'mooset/endpoints/gitlab/user'
 require 'mooset/endpoints/gitlab/group'
+require 'mooset/endpoints/gitlab/paginate'
 require 'mooset/endpoints/gitlab/user_search'
 require 'mooset/endpoints/gitlab/group_search'
 require 'mooset/endpoints/ldap'
 require 'mooset/endpoints/ldap/user'
 require 'mooset/endpoints/ldap/group'
-require 'mooset/endpoints/ldap/user_search'
-require 'mooset/endpoints/ldap/group_search'
-require 'mooset/endpoints/console_logger'
+require 'mooset/endpoints/ldap/ou'
+require 'mooset/endpoints/ldap/ldap_search'
 require 'mooset/endpoints/null'
 
 module Mooset

data/lib/mooset/resource.rb

@@ -2,15 +2,29 @@ module Mooset
   class Resource
     include Virtus.model
 
-    attribute :raw
-    attribute :endpoint_name
+    attr_reader :endpoint
 
-    def endpoint
-      Mooset.public_send(endpoint_name)
+    def self.finders(finder_list)
+      define_method :finders do
+        finder_list
+      end
     end
 
     def initialize(*args)
+      @endpoint = args[0][:endpoint]
+
       super(*args)
+
+      @logger = ::Logger.new(STDOUT)
+      @logger.info "{endpoint_name} -- build #{self.class.name} #{args.join(" ")}"
+    end
+
+    def to_json(*args)
+      attributes.to_json
+    end
+
+    def finders
+      []
     end
   end
 end

data/lib/mooset/synchronize_group.rb

@@ -0,0 +1,35 @@
+module Mooset
+  class SynchronizeGroups
+    attr_accessor :from, :to, :opts
+
+    def initialize(from, to, opts)
+      @from = from
+      @to = to
+      @opts = opts
+    end
+
+    def call
+      @from.groups.find(@opts[:query]).each do |group|
+        to_group = @to.groups.find(group)
+
+        if !to_group
+          to_group = @to.groups.import(group)
+        end
+
+        to_member_ids = to_group.members.map(&:id)
+
+        group.members.each do |user|
+          #next unless user.id =~ /Alexandru/
+
+          to_user = @to.users.find(user)
+
+          if !to_user
+            to_user = @to.users.import(user)
+          end
+
+          to_group << to_user unless to_member_ids.include?(to_user.id)
+        end
+      end
+    end
+  end
+end

data/lib/mooset/version.rb

@@ -1,3 +1,3 @@
 module Mooset
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/mooset.rb

@@ -10,6 +10,5 @@ require "mooset/models/user"
 require "mooset/models/group"
 
 require "mooset/endpoints"
-require "mooset/storage/memory"
 require "mooset/application"
-require "mooset/synchronize_users"
+require "mooset/synchronize_group"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mooset
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Alexandru Keszeg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-15 00:00:00.000000000 Z
+date: 2015-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gitlab
@@ -141,29 +141,28 @@ files:
 - lib/mooset/application.rb
 - lib/mooset/configuration.rb
 - lib/mooset/endpoints.rb
-- lib/mooset/endpoints/console_logger.rb
 - lib/mooset/endpoints/endpoint.rb
+- lib/mooset/endpoints/findable.rb
 - lib/mooset/endpoints/gitlab.rb
 - lib/mooset/endpoints/gitlab/group.rb
 - lib/mooset/endpoints/gitlab/group_search.rb
+- lib/mooset/endpoints/gitlab/paginate.rb
 - lib/mooset/endpoints/gitlab/user.rb
 - lib/mooset/endpoints/gitlab/user_search.rb
 - lib/mooset/endpoints/ldap.rb
 - lib/mooset/endpoints/ldap/group.rb
-- lib/mooset/endpoints/ldap/group_search.rb
+- lib/mooset/endpoints/ldap/ldap_search.rb
+- lib/mooset/endpoints/ldap/ou.rb
 - lib/mooset/endpoints/ldap/user.rb
-- lib/mooset/endpoints/ldap/user_search.rb
 - lib/mooset/endpoints/null.rb
 - lib/mooset/models/group.rb
 - lib/mooset/models/user.rb
 - lib/mooset/monads.rb
 - lib/mooset/resource.rb
-- lib/mooset/storage.rb
 - lib/mooset/storage/memory.rb
-- lib/mooset/synchronize_users.rb
+- lib/mooset/synchronize_group.rb
 - lib/mooset/version.rb
 - mooset.gemspec
-- spec/mooset/endpoints/gitlab_spec.rb
 - spec/mooset/endpoints/ldap_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -191,6 +190,5 @@ signing_key:
 specification_version: 4
 summary: A Ruby library and client for user migration.
 test_files:
-- spec/mooset/endpoints/gitlab_spec.rb
 - spec/mooset/endpoints/ldap_spec.rb
 - spec/spec_helper.rb

data/lib/mooset/endpoints/console_logger.rb

@@ -1,10 +0,0 @@
-module Mooset
-  module Endpoints
-    class ConsoleLogger < Endpoint
-      def write(user)
-        p user
-      end
-    end
-  end
-end
-

data/lib/mooset/endpoints/ldap/group_search.rb

@@ -1,31 +0,0 @@
-module Mooset
-  module Endpoints
-    class Ldap
-      class GroupSearch
-        GROUP_FILTER = "(objectClass=group)"
-
-        attr_reader :endpoint
-
-        def initialize(endpoint)
-          @endpoint = endpoint
-        end
-
-        def query(filter = GROUP_FILTER, base: endpoint.treebase)
-          connection.search(base: base, filter: filter).collect do |object|
-            Group.build(endpoint.endpoint_name, object)
-          end
-        end
-
-        def all
-          query(GROUP_FILTER)
-        end
-
-        private
-
-        def connection
-          @endpoint.connection
-        end
-      end
-    end
-  end
-end

data/lib/mooset/endpoints/ldap/user_search.rb

@@ -1,31 +0,0 @@
-module Mooset
-  module Endpoints
-    class Ldap
-      class UserSearch
-        USER_FILTER = "(objectClass=person)"
-
-        attr_reader :endpoint
-
-        def initialize(endpoint)
-          @endpoint = endpoint
-        end
-
-        def query(filter = USER_FILTER, base: endpoint.treebase)
-          connection.search(base: base, filter: filter).collect do |object|
-            User.build(endpoint.endpoint_name, object)
-          end
-        end
-
-        def all
-          query(USER_FILTER)
-        end
-
-        private
-
-        def connection
-          @endpoint.connection
-        end
-      end
-    end
-  end
-end

data/lib/mooset/storage.rb

@@ -1,6 +0,0 @@
-require 'mooset/storage/memory'
-
-module Mooset
-  module Storage
-  end
-end

data/lib/mooset/synchronize_users.rb

@@ -1,9 +0,0 @@
-module Mooset
-  class SynchronizeUsers
-    def self.call(from, to, opts)
-      from.users(opts[:query]).each do |user|
-        to.write(user)
-      end
-    end
-  end
-end

data/spec/mooset/endpoints/gitlab_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Mooset::Endpoints::Gitlab do
-  let(:storage) { double(exists?: false) }
-  let(:connection) { double }
-  let(:command) { Mooset::Endpoints::Gitlab.new(:gitlab, connection: connection, storage: storage) }
-
-  describe '#write' do
-    let(:user) do
-      double({
-        email: 'email',
-        extern_uid: '1',
-        username: 'username',
-        provider: 'ldap',
-      })
-    end
-
-    it "calls the create user api" do
-      expect(connection).to receive(:create_user).with(user.email, anything,{
-        extern_uid: user.extern_uid,
-        username: user.username,
-        provider: 'ldap',
-      })
-
-      command.write(user)
-    end
-
-    context 'when the user is already imported' do
-      let(:storage) { double }
-
-      it "doesn't create duplicate users" do
-        expect(storage).to receive(:exists?).with(user).and_return(true)
-        expect(connection).not_to receive(:create_user)
-
-        command.write(user)
-      end
-    end
-  end
-end