train-alicloud 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 70ab43053ff407de562c98318dd1e0926951729dcc3b021d661436f569ae5e7f
+  data.tar.gz: fc23966ae524f096879dc0dfe256a994d569c820b5328102f8896d47ae02a840
+SHA512:
+  metadata.gz: cf6670f8a94e0d406757a86ba52501423eb2337d13634ca018d61e8dc2b1046248dab67f012f32c64e28f7c559f310c024487e0d4661dd114d48234e94787f2e
+  data.tar.gz: 972218f9739808b247533091b3a037bfa4d4dabc005bd1afa9dd00684ba9b9328498724eaadb7315760f6b4f42c4418967ffce07068418333f699d895091b386

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2020 Chef Software Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/lib/train-alicloud.rb

@@ -0,0 +1,21 @@
+# This file is known as the "entry point."
+# This is the file Train will try to load if it
+# thinks your plugin is needed.
+
+# The *only* thing this file should do is setup the
+# load path, then load plugin files.
+
+# Next two lines simply add the path of the gem to the load path.
+# This is not needed when being loaded as a gem; but when doing
+# plugin development, you may need it.  Either way, it's harmless.
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+# It's traditonal to keep your gem version in a separate file, so CI can find it easier.
+require_relative "train-alicloud/version"
+
+# A train plugin has three components: Transport, Connection, and Platform.
+# Transport acts as the glue.
+require_relative "train-alicloud/transport"
+require_relative "train-alicloud/platform"
+require_relative "train-alicloud/connection"

data/lib/train-alicloud/connection.rb

@@ -0,0 +1,87 @@
+# Connection definition file for an example Train plugin.
+
+# Most of the work of a Train plugin happens in this file.
+# Connections derive from Train::Plugins::Transport::BaseConnection,
+# and provide a variety of services.  Later generations of the plugin
+# API will likely separate out these responsibilities, but for now,
+# some of the responsibilities include:
+# * authentication to the target
+# * platform / release /family detection
+# * caching
+# * API execution
+# * marshalling to / from JSON
+# You don't have to worry about most of this.
+
+# Push platform detection out to a mixin, as it tends
+# to develop at a different cadence than the rest
+require_relative "platform"
+require "train"
+require "train/plugins"
+
+require "aliyunsdkcore"
+
+module TrainPlugins
+  module AliCloud
+    # You must inherit from BaseConnection.
+    class Connection < Train::Plugins::Transport::BaseConnection
+      # We've placed platform detection in a separate module; pull it in here.
+      include TrainPlugins::AliCloud::Platform
+
+      def initialize(options)
+        # 'options' here is a hash, Symbol-keyed,
+        # of what Train.target_config decided to do with the URI that it was
+        # passed by `inspec -t` (or however the application gathered target information)
+        # Some plugins might use this moment to capture credentials from the URI,
+        # and the configure an underlying SDK accordingly.
+        # You might also take a moment to manipulate the options.
+        # Have a look at the Local, SSH, and AWS transports for ideas about what
+        # you can do with the options.
+
+        # Override for any cli options
+        # alicloud://region
+        options[:region] = options[:host] || options[:region]
+
+        # Now let the BaseConnection have a chance to configure itself.
+        super(options)
+
+        # Force enable caching.
+        enable_cache :api_call
+
+        # Why are we doing this?
+        ENV["ALICLOUD_REGION"] = @options[:region] if @options[:region]
+      end
+
+      def alicloud_client(api:, api_version:)
+        region = @options[:region]
+
+        endpoint ||= if api == "sts"
+                       "https://#{api}.aliyuncs.com"
+                     else
+                       "https://#{api}.#{region}.aliyuncs.com"
+                     end
+
+        RPCClient.new(
+          access_key_id:     @options[:access_key_id],
+          access_key_secret: @options[:secret_access_key],
+          endpoint:          endpoint,
+          api_version:       api_version
+        )
+      end
+
+      def alicloud_resource(klass, args)
+        klass.new(args)
+      end
+
+      # TODO: determine exactly what this is used for
+      def uri
+        "alicloud://#{@options[:region]}"
+      end
+
+      def unique_identifier
+        # use alicloud account id
+        caller_identity = alicloud_client(api: "sts", api_version: "2015-04-01").request(action: "GetCallerIdentity")
+        caller_identity["AccountId"]
+      end
+    end
+  end
+end

data/lib/train-alicloud/platform.rb

@@ -0,0 +1,39 @@
+require_relative "version"
+
+# Platform definition file.  This is a good place to separate out any
+# logic regarding the identification of the OS or API at the far end
+# of the connection.
+
+# Abbreviate the namespace here, if you like.
+module TrainPlugins::AliCloud
+  # Since we're mixing in the platform detection facility into Connection,
+  # this has to come in as a Module.
+  module Platform
+    # The method `platform` is called when platform detection is
+    # about to be performed.  Train core defines a sophisticated
+    # system for platform detection, but for most plugins, you'll
+    # only ever run on the special platform for which you are targeting.
+    def platform
+      # If you are declaring a new platform, you will need to tell
+      # Train a bit about it.
+      # If you were defining a cloud API, you should say you are a member
+      # of the cloud family.
+
+      # This plugin defines a new platform.
+      Train::Platforms.name("alicloud").in_family("cloud")
+
+      # When you know you will only ever run on your dedicated platform
+      # force_platform! lets you bypass platform detection.
+      # The options to this are not currently documented completely.
+
+      # Use release to report a version number.  You might use the version
+      # of the plugin, or a version of an important underlying SDK, or a
+      # version of a remote API.
+      alicloud_version = Gem.loaded_specs["aliyunsdkcore"].version
+      alicloud_version = "aliyunsdkcore: v#{alicloud_version}"
+      plugin_version = "train-alicloud: v#{TrainPlugins::AliCloud::VERSION}"
+
+      force_platform!("alicloud", release: "#{plugin_version}, #{alicloud_version}")
+    end
+  end
+end

data/lib/train-alicloud/transport.rb

@@ -0,0 +1,40 @@
+
+require "train"
+require "train/plugins"
+require "aliyunsdkcore"
+
+# Train Plugins v1 are usually declared under the TrainPlugins namespace.
+# Each plugin has three components: Transport, Connection, and Platform.
+# We'll only define the Transport here, but we'll refer to the others.
+require_relative "connection"
+
+module TrainPlugins
+  module AliCloud
+    class Transport < Train.plugin(1)
+      name "alicloud"
+
+      # Pass ENV vars in using a block to `option`.  This causes `
+      # option to lazy-evaluate the block to provide a default value.`
+      # Otherwise, we would read the ENV var (and set the default)
+      # once at compile time, which would make testing difficult.
+      # TODO: convert to thor-style defaults
+      option(:region, required: true) { ENV["ALICLOUD_REGION"] }
+      option(:access_key_id, required: true) { ENV["ALICLOUD_ACCESS_KEY"] }
+      option(:secret_access_key, required: true) { ENV["ALICLOUD_SECRET_KEY"] }
+
+      # The only thing you MUST do in a transport is a define a
+      # connection() method that returns a instance that is a
+      # subclass of BaseConnection.
+
+      # The options passed to this are undocumented and rarely used.
+      def connection(_instance_opts = nil)
+        # Typical practice is to cache the connection as an instance variable.
+        # Do what makes sense for your platform.
+        # @options here is the parsed options that the calling
+        # app handed to us at process invocation. See the Connection class
+        # for more details.
+        @connection ||= TrainPlugins::AliCloud::Connection.new(@options)
+      end
+    end
+  end
+end

data/lib/train-alicloud/version.rb

@@ -0,0 +1,10 @@
+# This file exists simply to record the version number of the plugin.
+# It is kept in a separate file, so that your gemspec can load it and
+# learn the current version without loading the whole plugin.  Also,
+# many CI servers can update this file when "version bumping".
+
+module TrainPlugins
+  module AliCloud
+    VERSION = "0.0.2".freeze
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: train-alicloud
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Chef InSpec Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aliyunsdkcore
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.16
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.16
+- !ruby/object:Gem::Dependency
+  name: aliyun-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Allows applications using Train to speak to AliCloud; handles authentication,
+  cacheing, and SDK dependency management.
+email:
+- inspec@chef.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/train-alicloud.rb
+- lib/train-alicloud/connection.rb
+- lib/train-alicloud/platform.rb
+- lib/train-alicloud/transport.rb
+- lib/train-alicloud/version.rb
+homepage: https://github.com/chef-customers/train-alicloud
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: AliCloud API Transport for Train
+test_files: []