en-aws-synchronizer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb9acf091bb20cffe0b9e7e28ff17ac86cc77ac265038a96697aff13fad93d70
-  data.tar.gz: 86f767e582ed1e7bff70f8db33cd55d2f0bd33f3c9c655cdc30d839be05c1bd7
+  metadata.gz: a6049098ca14645323c036be757a33d2c54382a3061d0d95e3bcb871038067aa
+  data.tar.gz: '038fb5c7e9f7da4c0449a8b22d3bb491f8afc8dedfaecaf8a4ef5d94c79f0d45'
 SHA512:
-  metadata.gz: c8e63fcd2832670605f6702962682227964581c80d5ae3481febb787ce5688d137bb2bbccdd15a9a8f3df386e427a0ec250909c737f3867db90b544c152de16b
-  data.tar.gz: 62a5293e1322fa133da9e13df1678eb193d64219943b5d1f44c013701de60b586958260f9798f9ec676ba052cc3a84beddc6c4ebc9f0f93df8c42bf580863ee8
+  metadata.gz: '094a8a6fe4220791d1e57ee23bb5ad35c46bf05cfd55dd05e44f2dbcec5541333d7baf348e3321713ab269e4816121ce96df6c0867dea6d80a34257e19a0f819'
+  data.tar.gz: b1ed3a516a7fd1e9887b6f823358d980c85cf5007ab1e31a347f3c3405c9201d29cbdfd49f2cc54e890c75a408e617638b9dfd2a4bebc66f85bde610f6142b62

data/README.md

@@ -1,25 +1,77 @@
-# Eaglenube Aws Synchronizer
+# en-aws-synchronizer
 
-Introducing this powerful gem, designed to seamlessly sync AWS resources to any Rails application model. Our innovative solution streamlines the process of integrating Amazon Web Services' cloud-based resources into your Ruby on Rails projects. With this gem, you can effortlessly connect AWS services like Vpc, Subnet, SecurityGroup, Snapshots, EC2, or RDS to your application models, enabling efficient data synchronization and management. Whether it's handling file storage, cloud computing, or database operations, this gem simplifies AWS resource integration, saving you time and effort. Say goodbye to complex setup processes and hello to a smoother, more streamlined experience, making AWS integration a breeze for your Rails applications.
+`en-aws-synchronizer` is a Ruby gem designed to seamlessly synchronize AWS services to your local database within a Rails application. This gem simplifies the process of fetching AWS resource data and mapping it to your ActiveRecord models.
+
+## Features
+
+- Seamless Synchronization: Sync AWS resources like EC2 Volumes to your local database effortlessly.
+- Custom Mappers: Define your custom mappers using YAML files to map AWS resource attributes to your database fields.
+- Extendable: Easily extend the functionality to sync other AWS services by creating custom mappers.
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'en-aws-synchronizer'
+```
+And then execute:
+```bash
+bundle install
+```
+
+## Usage
+
+1. Define Your Mapper
+Create a YAML file in __data/cloud_object_mappers/__ directory to map AWS service attributes to your model fields. For example, to map AWS EC2 Volumes, create __data/cloud_object_mappers/volume.yml__:
+
+```yaml
+name: (obj.tags || []).find { |t| t.key.eql?('Name') }.try(:value) || 'Undefined'
+service_id: obj.volume_id
+volume_type: obj.volume_type
+state: obj.state
+tags: obj.tags.to_h
+```
+2. Update Your Model
+In your model, include the synchronizer module and reference the mapper YAML file:
+
+```ruby
+require 'eaglenube/synchronizer/aws/volume'
 
-    $ bundle add en-aws-synchronizer
+class Volume < ApplicationRecord
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+  include Eaglenube::Synchronizer::AWS::Volume
 
-    $ gem install en-aws-synchronizer
+  cloud_obj_mapper_yml "data/cloud_object_mappers/volume.yml"
 
-## Contributing
+  def self.sync
+    credential = Aws::Credentials.new(<access_key_id>, <secret_access_key>)
+    
+    sync_resource(credential, "us-east-1") do |aws_volume|
+      db_composite_unique_identifers = { region_id: region.id, aws_service_id: aws_volume.volume_id }
 
-Bug reports and pull requests are welcome on GitHub at https://gitlab.com/eaglenube1/en_aws_synchronizer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://gitlab.com/eaglenube1/en_aws_synchronizer/blob/master/CODE_OF_CONDUCT.md).
+      extra_attributes = {}
+      [object_identifying_attributes, extra_attributes]
+    end
+  end
+end
+```
+3. Synchronize Data
+Call the sync method on your model to sync the AWS resources to your local database:
 
-## License
+```ruby
+Volume.sync
+```
+This will fetch the AWS EC2 Volume data and map the attributes according to the volume.yml mapper file, then save it to your database.
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+Customization
+You can extend this gem to sync other AWS resources by creating appropriate mappers and including the respective synchronizer module in your models.
 
-## Code of Conduct
+Example
+To sync another AWS resource, such as Vpc, follow these steps:
 
-Everyone interacting in the EnAwsSynchronizer project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://gitlab.com/eaglenube1/en_aws_synchronizer/blob/master/CODE_OF_CONDUCT.md).
+Create a new mapper YAML file, e.g., data/cloud_object_mappers/vpc.yml.
+Include the appropriate synchronizer module in your model.
+Implement the sync method in your model, similar to the Volume example.
+Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/your-username/en-aws-synchronizer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.

data/lib/eaglenube/api_wrapper/aws/acm_certificate.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module AcmCertificate
+
+        def list_certificates(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_acm_agent(credential, region_code)
+          agent.list_certificates.try(:certificate_summary_list)
+        end
+
+        def get_certificate(credential, region_code, certificate_arn)
+          agent = Eaglenube::AWSAgent.get_acm_agent(credential, region_code)
+          agent.get_certificate({ certificate_arn: certificate_arn })
+        end
+
+        def describe_certificate(credential, region_code, certificate_arn)
+          agent = Eaglenube::AWSAgent.get_acm_agent(credential, region_code)
+          agent.describe_certificate({ certificate_arn: certificate_arn })
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/db_snapshot.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module DbSnapshot
+        include Eaglenube::AWSAgent
+
+        def describe_db_snapshots(credential, region_code, **options)
+          agent = Eaglenube::AWSAgent.get_rds_agent(credential, region_code)
+          agent.describe_db_snapshots(options).try(:db_snapshots)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/elastic_ip.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module ElasticIp
+        include Eaglenube::AWSAgent
+
+        def describe_addresses(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_addresses.try(:addresses)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/iam_certificate.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module IamCertificate
+
+        def list_server_certificates(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_iam_agent(credential, region_code)
+          agent.list_server_certificates.try(:server_certificate_metadata_list)
+        end
+
+        def get_server_certificate(credential, region_code, certificate_name)
+          agent = Eaglenube::AWSAgent.get_iam_agent(credential, region_code)
+          agent.get_server_certificate({ server_certificate_name: certificate_name })
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/internet_gateway.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module InternetGateway
+        include Eaglenube::AWSAgent
+
+        def describe_internet_gateways(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_internet_gateways.try(:internet_gateways)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/key_pair.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module KeyPair
+
+        def describe_key_pairs(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_key_pairs.try(:key_pairs)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/loadbalancer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module Loadbalancer
+
+        def describe_load_balancers(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_elb_agent(credential, region_code)
+          agent.describe_load_balancers.try(:load_balancers) || []
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/security_group.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module SecurityGroup
+        include Eaglenube::AWSAgent
+
+        def describe_security_groups(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_security_groups.try(:security_groups)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/snapshot.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module Snapshot
+        include Eaglenube::AWSAgent
+
+        def describe_snapshots(credential, region_code, **options)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_snapshots(options).try(:snapshots)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/subnet.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module Subnet
+
+        def describe_subnets(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_subnets.try(:subnets)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/volume.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module Volume
+
+        def describe_volumes(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_volumes.try(:volumes)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/api_wrapper/aws/vpc.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "eaglenube/aws_agent"
+
+module Eaglenube
+  module ApiWrapper
+    module AWS
+      module Vpc
+
+        def describe_vpcs(credential, region_code)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_vpcs.try(:vpcs)
+        end
+
+        def describe_vpc_attribute(credential, region_code, **options)
+          agent = Eaglenube::AWSAgent.get_compute_agent(credential, region_code)
+          agent.describe_vpc_attribute(options)
+        end
+
+      end
+    end
+  end
+end

data/lib/eaglenube/aws_agent.rb

@@ -1,57 +1,55 @@
 # frozen_string_literal: true
 
+require "eaglenube/aws_credential_builder"
+
 module Eaglenube
   module AWSAgent
-    def get_compute_agent(customer_cred, region_code = "us-east-1")
+
+    extend Eaglenube::AWSCredentialBuilder
+
+    def self.get_compute_agent(customer_cred, region_code = "us-east-1")
       Aws::EC2::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_rds_agent(customer_cred, region_code = "us-east-1")
+    def self.get_rds_agent(customer_cred, region_code = "us-east-1")
       Aws::RDS::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_elb_agent(customer_cred, region_code = "us-east-1")
+    def self.get_elb_agent(customer_cred, region_code = "us-east-1")
       Aws::ElasticLoadBalancing::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_auto_scaling_agent(customer_cred, region_code = "us-east-1")
+    def self.get_auto_scaling_agent(customer_cred, region_code = "us-east-1")
       Aws::AutoScaling::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_s3_agent(customer_cred, region_code = "us-east-1")
+    def self.get_s3_agent(customer_cred, region_code = "us-east-1")
       Aws::S3::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_cloud_watch_agent(customer_cred, region_code = "us-east-1")
+    def self.get_cloud_watch_agent(customer_cred, region_code = "us-east-1")
       Aws::CloudWatch::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_redshift_agent(customer_cred, region_code = "us-east-1")
+    def self.get_redshift_agent(customer_cred, region_code = "us-east-1")
       Aws::Redshift::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_kms_agent(customer_cred, region_code = "us-east-1")
+    def self.get_kms_agent(customer_cred, region_code = "us-east-1")
       Aws::KMS::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_ecs_agent(customer_cred, region_code = "us-east-1")
+    def self.get_ecs_agent(customer_cred, region_code = "us-east-1")
       Aws::ECS::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_iam_agent(customer_cred, region_code = "us-east-1")
+    def self.get_iam_agent(customer_cred, region_code = "us-east-1")
       Aws::IAM::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def get_acm_agent(customer_cred, region_code = "us-east-1")
+    def self.get_acm_agent(customer_cred, region_code = "us-east-1")
       Aws::ACM::Client.new(region: region_code, credentials: build_credential(customer_cred))
     end
 
-    def build_credential(credential)
-      if credential[:session_token].blank?
-        Aws::Credentials.new(credential[:access_key_id], credential[:secret_access_key])
-      else
-        Aws::Credentials.new(credential[:access_key_id], credential[:secret_access_key], credential[:session_token])
-      end
-    end
   end
 end

data/lib/eaglenube/aws_credential_builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Eaglenube
+  module AWSCredentialBuilder
+
+    def build_credential(credential)
+      if credential[:session_token].blank?
+        Aws::Credentials.new(credential[:access_key_id], credential[:secret_access_key])
+      else
+        Aws::Credentials.new(credential[:access_key_id], credential[:secret_access_key], credential[:session_token])
+      end
+    end
+
+  end
+end

data/lib/eaglenube/synchronizer/aws/acm_certificate.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "eaglenube/api_wrapper/aws/acm_certificate"
+require "eaglenube/synchronizer/aws"
+require "eaglenube/cloud_object_mapper/aws"
+
+# Eaglenube::Synchronizer::AWS::AcmCertificate
+module Eaglenube
+  module Synchronizer
+    module AWS
+      module AcmCertificate
+        def self.included(receiver)
+          receiver.extend Eaglenube::Synchronizer::AWS::CommonMethods
+          receiver.extend AcmSyncMethods
+        end
+
+        module AcmSyncMethods
+          include Eaglenube::ApiWrapper::AWS::AcmCertificate
+          include Eaglenube::CloudObjectMapper::AWS
+
+          def sync_resource(credential, region_code)
+            remote_acm_certificates = list_certificates(credential, region_code)
+            remote_acm_certificates.each do |remote_acm_certificate|
+              object_identifying_attributes, optional_attributes = yield(remote_acm_certificate)
+              create_or_update(remote_acm_certificate, object_identifying_attributes, **optional_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eaglenube/synchronizer/aws/db_snapshot.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/db_snapshot"
 require "eaglenube/synchronizer/aws"
 require "eaglenube/cloud_object_mapper/aws"
 
@@ -15,17 +15,11 @@ module Eaglenube
         end
 
         module DbSnapshotSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::DbSnapshot
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_remote_db_snapshots(credential, region_code)
-            agent = get_rds_agent(credential, region_code)
-            agent.describe_db_snapshots({ include_public: false, include_shared: true,
-                                          snapshot_type: "manual" }).try(:db_snapshots)
-          end
-
-          def sync(credential, region_code)
-            remote_db_snapshots = list_all_remote_db_snapshots(credential, region_code)
+          def sync_resource(credential, region_code, **options)
+            remote_db_snapshots = describe_db_snapshots(credential, region_code, **options)
             remote_db_snapshots.each do |remote_db_snapshot|
               object_identifying_attributes, optional_attributes = yield(remote_db_snapshot)
               create_or_update(remote_db_snapshot, object_identifying_attributes, **optional_attributes)

data/lib/eaglenube/synchronizer/aws/elastic_ip.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/elastic_ip"
 require "eaglenube/synchronizer/aws"
 require "eaglenube/cloud_object_mapper/aws"
 
@@ -15,16 +15,11 @@ module Eaglenube
         end
 
         module EipSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::ElasticIp
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_elastic_ips(credential, region_code)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_addresses.try(:addresses)
-          end
-
-          def sync(credential, region_code)
-            remote_eips = list_all_elastic_ips(credential, region_code)
+          def sync_resource(credential, region_code)
+            remote_eips = describe_addresses(credential, region_code)
             remote_eips.each do |remote_eip|
               object_identifying_attributes, optional_attributes = yield(remote_eip)
               create_or_update(remote_eip, object_identifying_attributes, **optional_attributes)

data/lib/eaglenube/synchronizer/aws/iam_certificate.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "eaglenube/api_wrapper/aws/iam_certificate"
+require "eaglenube/synchronizer/aws"
+require "eaglenube/cloud_object_mapper/aws"
+
+# Eaglenube::Synchronizer::AWS::IamCertificate
+module Eaglenube
+  module Synchronizer
+    module AWS
+      module IamCertificate
+        def self.included(receiver)
+          receiver.extend Eaglenube::Synchronizer::AWS::CommonMethods
+          receiver.extend IamCertificateSyncMethods
+        end
+
+        module IamCertificateSyncMethods
+          include Eaglenube::ApiWrapper::AWS::IamCertificate
+          include Eaglenube::CloudObjectMapper::AWS
+
+          def sync_resource(credential, region_code)
+            remote_iam_certificates = list_server_certificates(credential, region_code)
+            remote_iam_certificates.each do |remote_iam_certificate|
+              object_identifying_attributes, optional_attributes = yield(remote_iam_certificate)
+              create_or_update(remote_iam_certificate, object_identifying_attributes, **optional_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eaglenube/synchronizer/aws/key_pair.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "eaglenube/api_wrapper/aws/key_pair"
+require "eaglenube/synchronizer/aws"
+require "eaglenube/cloud_object_mapper/aws"
+
+# Eaglenube::Synchronizer::AWS::KeyPair
+module Eaglenube
+  module Synchronizer
+    module AWS
+      module KeyPair
+        def self.included(receiver)
+          receiver.extend Eaglenube::Synchronizer::AWS::CommonMethods
+          receiver.extend KeyPairSyncMethods
+        end
+
+        module KeyPairSyncMethods
+          include Eaglenube::ApiWrapper::AWS::KeyPair
+          include Eaglenube::CloudObjectMapper::AWS
+
+          def sync_resource(credential, region_code)
+            remote_key_pairs = describe_key_pairs(credential, region_code)
+            remote_key_pairs.each do |remote_key_pair|
+              object_identifying_attributes, optional_attributes = yield(remote_key_pair)
+              create_or_update(remote_key_pair, object_identifying_attributes, **optional_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eaglenube/synchronizer/aws/loadbalancer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "eaglenube/api_wrapper/aws/loadbalancer"
+require "eaglenube/synchronizer/aws"
+require "eaglenube/cloud_object_mapper/aws"
+
+# Eaglenube::Synchronizer::AWS::Loadbalancer
+module Eaglenube
+  module Synchronizer
+    module AWS
+      module Loadbalancer
+        def self.included(receiver)
+          receiver.extend Eaglenube::Synchronizer::AWS::CommonMethods
+          receiver.extend LbSyncMethods
+        end
+
+        module LbSyncMethods
+          include Eaglenube::ApiWrapper::AWS::Loadbalancer
+          include Eaglenube::CloudObjectMapper::AWS
+
+          def sync_resource(credential, region_code)
+            remote_load_balancers = describe_load_balancers(credential, region_code)
+            remote_load_balancers.each do |remote_load_balancer|
+              object_identifying_attributes, optional_attributes = yield(remote_load_balancer)
+              create_or_update(remote_load_balancer, object_identifying_attributes, **optional_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eaglenube/synchronizer/aws/security_group.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/security_group"
 require "eaglenube/cloud_object_mapper/aws"
 
 module Eaglenube
@@ -13,16 +13,11 @@ module Eaglenube
         end
 
         module SecurityGroupSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::SecurityGroup
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_remote_security_groups(credential, region_code)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_security_groups.try(:security_groups)
-          end
-
-          def sync(credential, region_code)
-            remote_security_groups = list_all_remote_security_groups(credential, region_code)
+          def sync_resource(credential, region_code)
+            remote_security_groups = describe_security_groups(credential, region_code)
             remote_security_groups.each do |remote_security_group|
               object_identifying_attributes, optional_attributes = yield(remote_security_group)
               create_or_update(remote_security_group, object_identifying_attributes, **optional_attributes)

data/lib/eaglenube/synchronizer/aws/snapshot.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/snapshot"
 require "eaglenube/synchronizer/aws"
 require "eaglenube/cloud_object_mapper/aws"
 
@@ -15,16 +15,11 @@ module Eaglenube
         end
 
         module SnapshotSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::Snapshot
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_remote_snapshots(credential, region_code, aws_account_id)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_snapshots({ owner_ids: [aws_account_id] }).try(:snapshots)
-          end
-
-          def sync(credential, region_code, aws_account_id)
-            remote_snapshots = list_all_remote_snapshots(credential, region_code, aws_account_id)
+          def sync_resource(credential, region_code, **options)
+            remote_snapshots = describe_snapshots(credential, region_code, **options)
             remote_snapshots.each do |remote_snapshot|
               object_identifying_attributes, optional_attributes = yield(remote_snapshot)
               create_or_update(remote_snapshot, object_identifying_attributes, **optional_attributes)

data/lib/eaglenube/synchronizer/aws/subnet.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/subnet"
 require "eaglenube/synchronizer/aws"
 require "eaglenube/cloud_object_mapper/aws"
 
@@ -14,16 +14,11 @@ module Eaglenube
         end
 
         module SubnetSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::Subnet
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_remote_subnets(credential, region_code)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_subnets.try(:subnets)
-          end
-
-          def sync(credential, region_code, &_block)
-            remote_subnets = list_all_remote_subnets(credential, region_code)
+          def sync_resource(credential, region_code, &_block)
+            remote_subnets = describe_subnets(credential, region_code)
             remote_subnets.each do |remote_subnet|
               object_identifying_attributes, optional_attributes = yield(remote_subnet)
               create_or_update(remote_subnet, object_identifying_attributes, **optional_attributes)

data/lib/eaglenube/synchronizer/aws/volume.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/volume"
 require "eaglenube/synchronizer/aws"
 require "eaglenube/cloud_object_mapper/aws"
 
@@ -15,16 +15,11 @@ module Eaglenube
         end
 
         module VolumeSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::Volume
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_remote_volumes(credential, region_code)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_volumes.try(:volumes)
-          end
-
-          def sync(credential, region_code, &_block)
-            remote_volumes = list_all_remote_volumes(credential, region_code)
+          def sync_resource(credential, region_code, &_block)
+            remote_volumes = describe_volumes(credential, region_code)
             remote_volumes.each do |remote_volume|
               object_identifying_attributes, optional_attributes = yield(remote_volume)
               create_or_update(remote_volume, object_identifying_attributes, **optional_attributes)

data/lib/eaglenube/synchronizer/aws/vpc.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "eaglenube/aws_agent"
+require "eaglenube/api_wrapper/aws/vpc"
 require "eaglenube/synchronizer/aws"
 require "eaglenube/cloud_object_mapper/aws"
 
@@ -10,30 +10,16 @@ module Eaglenube
     module AWS
       module Vpc
         def self.included(receiver)
-          puts "receiver module name: #{receiver}"
-          # module_name = Eaglenube::Synchronizer.config.find_sync_module(receiver)
-          # puts "module name to extend: #{module_name}"
-          # receiver.extend module_name if defined?(receiver)
           receiver.extend Eaglenube::Synchronizer::AWS::CommonMethods
           receiver.extend VpcSyncMethods
         end
 
         module VpcSyncMethods
-          include Eaglenube::AWSAgent
+          include Eaglenube::ApiWrapper::AWS::Vpc
           include Eaglenube::CloudObjectMapper::AWS
 
-          def list_all_remote_vpcs(credential, region_code)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_vpcs.try(:vpcs)
-          end
-
-          def list_all_remote_igs(credential, region_code)
-            agent = get_compute_agent(credential, region_code)
-            agent.describe_internet_gateways.try(:internet_gateways)
-          end
-
-          def sync(credential, region_code)
-            remote_vpcs = list_all_remote_vpcs(credential, region_code)
+          def sync_resource(credential, region_code)
+            remote_vpcs = describe_vpcs(credential, region_code)
             describe_vpc_attribute_permisssion_error = false
             remote_vpcs.each do |remote_vpc|
               object_identifying_attributes, optional_attributes = yield(remote_vpc)
@@ -54,11 +40,10 @@ module Eaglenube
           end
 
           def sync_addtional_attributes(credential, region_code, vpc_id)
-            agent = get_compute_agent(credential, region_code)
             dns_support_attrs = { vpc_id: vpc_id, attribute: "enableDnsSupport" }
-            dns_support = agent.describe_vpc_attribute(dns_support_attrs).try(:enable_dns_support).try(:value)
+            dns_support = describe_vpc_attribute(credential, region_code, **dns_support_attrs).try(:enable_dns_support).try(:value)
             dns_hostname_attrs = { vpc_id: vpc_id, attribute: "enableDnsHostnames" }
-            dns_hostname = agent.describe_vpc_attribute(dns_hostname_attrs).try(:enable_dns_hostnames).try(:value)
+            dns_hostname = describe_vpc_attribute(credential, region_code, **dns_hostname_attrs).try(:enable_dns_hostnames).try(:value)
             [dns_support, dns_hostname]
           end
         end

data/lib/eaglenube/synchronizer/version.rb

@@ -2,6 +2,6 @@
 
 module Eaglenube
   module Synchronizer
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/en_aws_synchronizer.rb

@@ -5,3 +5,6 @@ require "eaglenube/cloud_object_mapper/aws"
 require "eaglenube/synchronizer/aws"
 
 require "eaglenube/synchronizer"
+
+require "eaglenube/api_wrapper/aws"
+require "eaglenube/api_wrapper"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: en-aws-synchronizer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eaglenube
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-20 00:00:00.000000000 Z
+date: 2024-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-acm
@@ -179,12 +179,29 @@ files:
 - README.md
 - Rakefile
 - en_aws_synchronizer.gemspec
+- lib/eaglenube/api_wrapper/aws/acm_certificate.rb
+- lib/eaglenube/api_wrapper/aws/db_snapshot.rb
+- lib/eaglenube/api_wrapper/aws/elastic_ip.rb
+- lib/eaglenube/api_wrapper/aws/iam_certificate.rb
+- lib/eaglenube/api_wrapper/aws/internet_gateway.rb
+- lib/eaglenube/api_wrapper/aws/key_pair.rb
+- lib/eaglenube/api_wrapper/aws/loadbalancer.rb
+- lib/eaglenube/api_wrapper/aws/security_group.rb
+- lib/eaglenube/api_wrapper/aws/snapshot.rb
+- lib/eaglenube/api_wrapper/aws/subnet.rb
+- lib/eaglenube/api_wrapper/aws/volume.rb
+- lib/eaglenube/api_wrapper/aws/vpc.rb
 - lib/eaglenube/aws_agent.rb
+- lib/eaglenube/aws_credential_builder.rb
 - lib/eaglenube/cloud_object_mapper/aws.rb
 - lib/eaglenube/synchronizer.rb
 - lib/eaglenube/synchronizer/aws.rb
+- lib/eaglenube/synchronizer/aws/acm_certificate.rb
 - lib/eaglenube/synchronizer/aws/db_snapshot.rb
 - lib/eaglenube/synchronizer/aws/elastic_ip.rb
+- lib/eaglenube/synchronizer/aws/iam_certificate.rb
+- lib/eaglenube/synchronizer/aws/key_pair.rb
+- lib/eaglenube/synchronizer/aws/loadbalancer.rb
 - lib/eaglenube/synchronizer/aws/security_group.rb
 - lib/eaglenube/synchronizer/aws/snapshot.rb
 - lib/eaglenube/synchronizer/aws/subnet.rb
@@ -202,7 +219,7 @@ licenses:
 metadata:
   homepage_uri: https://gitlab.com/eaglenube1/en_aws_synchronizer
   source_code_uri: https://gitlab.com/eaglenube1/en_aws_synchronizer
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -217,8 +234,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Synchronize your aws resource to your rails model
 test_files: []