adap 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63f5d0cc91cadfe37b62c84602420c11adb34b8e80f3f60ff51a767e75621788
-  data.tar.gz: 9780fc3c0145805bcb042d5c4df8018b6d8df5ab824b1fd1c5a74e5103934627
+  metadata.gz: '0027496e73b5ac4ad67838975ca7876a4d9efed7b64de41733b1ef85b591f893'
+  data.tar.gz: 6fcaf2a2f8506dff5c606593f2565ee5b853ff672eaecd7d9e2a27b41108431d
 SHA512:
-  metadata.gz: c0fa71f2e0ba6edc95c710ee05e242f4eb1af904dcfa5a5157bd58afa57c0f4ce3afe7a76a408afbd0e0b33f2d559204f7b1215015f7e26517e92b089cd2610a
-  data.tar.gz: dd285ad4b31c0c4d730d200ac98e0b419ba65ace520218f99945e70df50a2841c498a5074a28537d11e5ae034eaf33a4b728c25629be562a06396c76efab3634
+  metadata.gz: fa4f5affabb9498f6d0f3a2802807fedfdb975870102fb16ba67fc9e0d9ff69c0b17cf3c1c5baf5c3b847f6aabd149f3114f778f8f45683fe0d81d6390118ba3
+  data.tar.gz: 9e19e2633f89514187f1f5a5472f62933f89d604399a3aafb56b674735f4784f58e2d7459c2160877ec800c3a966f84e27dfc5c6f6831f6fd4e4af62a285dff5

data/README_FOR_DEVELOPER.md

@@ -0,0 +1,48 @@
+# To run workflow
+
+# GitHub Actions
+## For unit testing
+When you push to any branch "master", "develop" or merge a PR to "master", the unit tests will run automatically.
+Please check the progress in the Actions tab.
+
+
+## For release (interactively)
+First, you need to modify a version in `./lib/adap/version.py`.
+Then, you can run the following command to trigger the release workflow.
+
+```
+$ vim lib/adap/version.rb
+  -> Update VERSION
+```
+
+Then create a commit and push it and create a PR.
+After it was merged, you can run the following command to trigger the release workflow.
+
+```
+$ gh workflow run
+? Select a workflow  [Use arrows to move, type to filter]
+> Ruby (release.yml)                                       // <- Select "Ruby (release.yml)"
+  Ruby (ruby.yml)
+  Dependabot Updates (dependabot-updates)
+
+? otp (required)                                           // <- Input the OTP code
+```
+
+
+
+```
+$ gh run list --workflow=release.yml
+STATUS  TITLE  WORKFLOW  BRANCH  EVENT              ID           ELAPSED  AGE
+*       Ruby   Ruby      master  workflow_dispatch  12673039585  10s      less than a minute ago
+```
+
+
+## For release (non-interactively)
+You can also trigger the release workflow non-interactively.
+
+```
+gh workflow run release.yml --ref=master --field otp=123456
+```
+
+`--field otp=123456` is required to input the OTP code.
+You have to change `123456` to the actual OTP code.

data/lib/adap/adap.rb

@@ -19,8 +19,8 @@ class Adap
   def initialize(params)
     raise "Initialize Adap was failed. params must not be nil" if params == nil
 
-    [:ad_host, :ad_binddn, :ad_user_basedn, :ad_group_basedn, :ldap_host, :ldap_binddn, :ldap_user_basedn, :ldap_group_basedn].each { |k|
-      raise 'Adap requires keys in params ":ad_host", ":ad_binddn", ":ad_user_basedn", ":ad_group_basedn", ":ldap_host", ":ldap_binddn", ":ldap_user_basedn", ":ldap_group_basedn"' if !params.key?(k)
+    [:ad_host, :ad_bind_dn, :ad_user_base_dn, :ad_group_base_dn, :ldap_host, :ldap_bind_dn, :ldap_user_base_dn, :ldap_group_base_dn].each { |k|
+      raise 'Adap requires keys in params ":ad_host", ":ad_bind_dn", ":ad_user_base_dn", ":ad_group_base_dn", ":ldap_host", ":ldap_bind_dn", ":ldap_user_base_dn", ":ldap_group_base_dn"' if !params.key?(k)
     }
 
     # List of attributes for user in AD
@@ -41,17 +41,17 @@ class Adap
 
     @ad_host                  = params[:ad_host]
     @ad_port                  = (params[:ad_port] ? params[:ad_port] : 389)
-    @ad_binddn                = params[:ad_binddn]
-    @ad_user_basedn           = params[:ad_user_basedn]
-    @ad_group_basedn          = params[:ad_group_basedn]
-    @ad_auth                  = (params.has_key?(:ad_password) ? { :method => :simple, :username => @ad_binddn, :password => params[:ad_password] } : nil)
+    @ad_bind_dn               = params[:ad_bind_dn]
+    @ad_user_base_dn          = params[:ad_user_base_dn]
+    @ad_group_base_dn         = params[:ad_group_base_dn]
+    @ad_auth                  = (params.has_key?(:ad_password) ? { :method => :simple, :username => @ad_bind_dn, :password => params[:ad_password] } : nil)
     @ldap_host                = params[:ldap_host]
     @ldap_port                = (params[:ldap_port] ? params[:ldap_port] : 389)
-    @ldap_binddn              = params[:ldap_binddn]
-    @ldap_basedn              = params[:ldap_basedn]
-    @ldap_user_basedn         = params[:ldap_user_basedn]
-    @ldap_group_basedn        = params[:ldap_group_basedn]
-    @ldap_auth                = (params.has_key?(:ldap_password) ? { :method => :simple, :username => @ldap_binddn, :password => params[:ldap_password] } : nil )
+    @ldap_bind_dn             = params[:ldap_bind_dn]
+    @ldap_base_dn             = params[:ldap_base_dn]
+    @ldap_user_base_dn        = params[:ldap_user_base_dn]
+    @ldap_group_base_dn       = params[:ldap_group_base_dn]
+    @ldap_auth                = (params.has_key?(:ldap_password) ? { :method => :simple, :username => @ldap_bind_dn, :password => params[:ldap_password] } : nil )
 
     # A password-hash algorithm to sync to the LDAP.
     # Popular LDAP products like Open LDAP usually supports md5({MD5}), sha1({SHA}) and ssha({SSHA}) algorithms.
@@ -101,11 +101,11 @@ class Adap
   end
 
   def get_ad_user_dn(username)
-    "CN=#{username},#{@ad_user_basedn}"
+    "CN=#{username},#{@ad_user_base_dn}"
   end
 
   def get_ldap_user_dn(username)
-    "uid=#{username},#{@ldap_user_basedn}"
+    "uid=#{username},#{@ldap_user_base_dn}"
   end
 
   def create_ldap_attributes(ad_entry)
@@ -342,26 +342,26 @@ class Adap
     # Creating AD ldapsearch filter
 
     ad_filter = if primary_gid_number == nil then
-      # TODO: Searching with filter `objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_basedn}` is more accureate.
+      # TODO: Searching with filter `objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_base_dn}` is more accureate.
       #Net::LDAP::Filter.construct(
-      #    "(&(objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_basedn})(member=CN=#{uid},CN=Users,#{@ad_basedn}))")
+      #    "(&(objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_base_dn})(member=CN=#{uid},CN=Users,#{@ad_base_dn}))")
 
       Net::LDAP::Filter.construct(
-          "(&(objectClass=group)(member=CN=#{uid},#{@ad_user_basedn}))")
+          "(&(objectClass=group)(member=CN=#{uid},#{@ad_user_base_dn}))")
     else
-      # TODO: Searching with filter `objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_basedn}` is more accureate.
+      # TODO: Searching with filter `objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_base_dn}` is more accureate.
       #Net::LDAP::Filter.construct(
-      #    "(&(objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_basedn})(|(member=CN=#{uid},CN=Users,#{@ad_basedn})(gidNumber=#{primary_gid_number})))")
+      #    "(&(objectCategory=CN=Group,CN=Schema,CN=Configuration,#{@ad_base_dn})(|(member=CN=#{uid},CN=Users,#{@ad_base_dn})(gidNumber=#{primary_gid_number})))")
 
       Net::LDAP::Filter.construct(
-          "(&(objectClass=group)(|(member=CN=#{uid},#{@ad_user_basedn})(gidNumber=#{primary_gid_number})))")
+          "(&(objectClass=group)(|(member=CN=#{uid},#{@ad_user_base_dn})(gidNumber=#{primary_gid_number})))")
     end
 
     # Get groups from AD
     # entry = {
     #   :gidnumber => xxx,
     # }
-    @ad_client.search(:base => @ad_group_basedn, :filter => ad_filter, :attributes => [:cn, :gidnumber]) do |entry|
+    @ad_client.search(:base => @ad_group_base_dn, :filter => ad_filter, :attributes => [:cn, :gidnumber]) do |entry|
       ad_group_map[entry[:cn].first] = {:gidnumber => entry[:gidnumber]}
       #ad_group_map[entry[:cn]] = nil
     end
@@ -377,7 +377,7 @@ class Adap
     ldap_filter = Net::LDAP::Filter.construct("(memberUid=#{uid})")
 
     # Get groups from LDAP
-    @ldap_client.search(:base => @ldap_group_basedn, :filter => ldap_filter, :attributes => [:cn]) do |entry|
+    @ldap_client.search(:base => @ldap_group_base_dn, :filter => ldap_filter, :attributes => [:cn]) do |entry|
       # Capture common name of groups. gidnumber is not necessary for LDAP entry
       ldap_group_map[entry[:cn].first] = nil
     end
@@ -416,7 +416,7 @@ class Adap
     operation_pool = {}
 
     ad_group_map.each_key do |key|
-      dn = "cn=#{key},#{@ldap_group_basedn}"
+      dn = "cn=#{key},#{@ldap_group_base_dn}"
       # Convert AD entries to LDAP entries to create operation to update LDAP data.
       operation_pool[dn] = {
         :cn => key,
@@ -426,7 +426,7 @@ class Adap
     end
 
     ldap_group_map.each_key do |key|
-      operation_pool["cn=#{key},#{@ldap_group_basedn}"] = {
+      operation_pool["cn=#{key},#{@ldap_group_base_dn}"] = {
         # :cn and :gidnumber are not necessary
         :operations => [[:delete, :memberuid, uid]]
       } if !ad_group_map.has_key?(key)
@@ -555,7 +555,7 @@ class Adap
     return nil if uid ==nil
     primary_gid = nil
 
-    @ad_client.search(:base => "CN=#{uid},CN=Users,#{@ad_basedn}") do |entry|
+    @ad_client.search(:base => "CN=#{uid},CN=Users,#{@ad_base_dn}") do |entry|
       primary_gid = entry[:gidnumber].first
     end
 

data/lib/adap/version.rb

@@ -1,3 +1,3 @@
 module ModAdap
-  VERSION = "0.1.10"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adap
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors:
 - Tsutomu Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-08 00:00:00.000000000 Z
+date: 2025-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,6 +65,7 @@ files:
 - Gemfile
 - Gemfile.lock
 - README.md
+- README_FOR_DEVELOPER.md
 - Rakefile
 - adap.gemspec
 - bin/console