aws_student_accounts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77ee4734b87a0f54963c15ea30d20b7850033965
+  data.tar.gz: 5ecfe71ef0faa3fadd3443919a88af827c2594a8
+SHA512:
+  metadata.gz: 01c95b0019e0844bb058d65dfc46d967632ba5eccfe95f455d3d8cc9000a71226efe90eed3c443a04baffc09967ca97e3b5ecc7a59be4a2dceea3145b06e3014
+  data.tar.gz: fdf2a412089a871ef4cf9681ef623fbc5cee32159e48ca276376379694067cfb3313b9e5506df5b6a3fa95769d2ed3b733add75b6c56ddf8164c2d4963fdca40

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+students

data/.rspec

@@ -0,0 +1,3 @@
+--format progress
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aws_student_accounts.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Dr Nic Williams
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+AWS Student Accounts
+====================
+
+Manage student AWS accounts in bulk.
+
+-	Consumes a single `.fog` file of AWS accounts with master credentials
+-	Creates/deletes temporary student IAM credentials
+	-	Emits a `.fog` file for API access
+	-	Emits a username/password file for AWS Console access
+-	Cleans out all VMs, disk, elastic IPs, AMIs, VPCs from student accounts
+
+Requires
+--------
+
+-	Ruby 1.9+
+-	RubyGems
+
+Installation
+------------
+
+Install using RubyGems:
+
+```
+$ gem install aws_student_accounts
+```
+
+Usage
+-----
+
+### Verify list of API credentials are valid
+
+```
+aws_student_accounts verify-credentials -C path/to/fog.yml
+```
+
+### Create student IAM access
+
+Create a student IAM account for all AWS accounts
+
+```
+aws_student_accounts create-students \
+  -C path/to/fog.yml \
+  --signin-urls path/to/signin-urls.yml \
+  [path/to/students]
+```
+
+For each account key in `path/to/fog.yml` there must be a mapping to the signin URL for that account in `path/to/signin-urls.yml`.
+
+E.g.
+
+```yaml
+:student1: https://093368509744.signin.aws.amazon.com/console
+:student2: https://012345678901.signin.aws.amazon.com/console
+```
+
+`path/to/students` will be a folder (defaults to `students` in current folder) into which the following files are created:
+
+-	`students-fog-api.yml` - the AWS credentials for all students' to access their allocated AWS accounts
+-	`students-console-passwords.md` - the AWS console username/passwords for students' to access their allocated AWS accounts
+
+### Delete student IAM access
+
+Delete temporary student IAM accounts.
+
+```
+aws_student_accounts delete-students -C path/to/fog.yml
+```
+
+### Cleans accounts
+
+Clean out all VMs, disk, elastic IPs, AMIs, VPCs from student accounts
+
+```
+aws_student_accounts clean-accounts -C path/to/fog.yml
+```
+
+### Options
+
+All commands will perform the account upon all accounts listed in the `-C fog.yml` file provided.
+
+You can filter down to 1+ accounts with a comma separated list `--only student1,student2`.
+
+You can ignore 1+ accounts from the `-C` list with `-i student19,student20`.
+
+Experiment with these options using the read-only `aws_student_accounts verify-credentials` command.
+
+Contributing
+------------
+
+1.	Fork it ( https://github.com/[my-github-username]/aws_student_accounts/fork )
+2.	Create your feature branch (`git checkout -b my-new-feature`\)
+3.	Commit your changes (`git commit -am 'Add some feature'`\)
+4.	Push to the branch (`git push origin my-new-feature`\)
+5.	Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/aws_student_accounts.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aws_student_accounts/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aws_student_accounts"
+  spec.version       = AwsStudentAccounts::VERSION
+  spec.authors       = ["Dr Nic Williams"]
+  spec.email         = ["drnicwilliams@gmail.com"]
+  spec.summary       = %q{Manage student AWS accounts in bulk}
+  spec.description   = %q{Manage student AWS accounts in bulk}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 0.19"
+  spec.add_dependency "fog", "~> 1.26"
+  spec.add_dependency "parallel"
+  spec.add_dependency "thread_safe"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/bin/aws_student_accounts

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require 'aws_student_accounts'
+
+AwsStudentAccounts::App.start(ARGV, :debug => true)

data/lib/aws_student_accounts.rb

@@ -0,0 +1,6 @@
+require "aws_student_accounts/version"
+require "aws_student_accounts/app"
+
+module AwsStudentAccounts
+  # Your code goes here...
+end

data/lib/aws_student_accounts/app.rb

@@ -0,0 +1,535 @@
+require "thor"
+require "yaml"
+require "fog"
+require "thread_safe"
+require "parallel"
+
+class AwsStudentAccounts::App < Thor
+  include Thor::Actions
+
+  attr_reader :fog_credentials
+
+  def self.common_options
+    method_option :fog_file, desc: "Path to YAML file of fog credentials",
+                    type: :string, aliases: "-C", required: true
+    method_option :only, desc: "Restrict to comma-separated list of fog keys",
+                    type: :string, aliases: "-o"
+  end
+
+  desc "verify-credentials", "Verify AWS credentials"
+  common_options
+  def verify_credentials
+    load_and_verify_options
+    @io_semaphore = Mutex.new
+    Parallel.each(fog_credentials, in_threads: 10) do |username, credentials|
+      begin
+        account = account_summary(credentials)
+        server_count = account[:servers]
+        @io_semaphore.synchronize do
+          say "#{username}: "
+          say "OK ", :green
+          say "(#{server_count} vm)"
+        end
+      rescue => e
+        @io_semaphore.synchronize do
+          say "#{username}: "
+          say e.message, :red
+        end
+      end
+    end
+  end
+
+  desc "create-students", "Create a student IAM account for all AWS accounts"
+  common_options
+  method_option :signin_urls, desc: "File mapping usernames to account signin URLs",
+    type: :string, aliases: "-s", required: true
+  def create_students(path_to_student_folders="students")
+    load_and_verify_options
+    @io_semaphore = Mutex.new
+
+    signin_urls = YAML.load_file(options[:signin_urls])
+
+    @users_credentials = ThreadSafe::Hash.new
+    @users_passwords = ThreadSafe::Hash.new
+
+    FileUtils.mkdir_p(path_to_student_folders)
+    FileUtils.chdir(path_to_student_folders) do
+      Parallel.each(fog_credentials, in_threads: fog_credentials.size) do |username, credentials|
+        create_student_user(username, credentials, signin_urls)
+      end
+
+      File.open("students-fog-api.yml", "w") do |f|
+        f << @users_credentials.to_yaml
+      end
+      say "Stored all user API credentials: #{File.expand_path('students-fog-api.yml')}"
+
+      File.open("students-console-passwords.md", "w") do |f|
+        f << "# Student AWS logins\n\n"
+        fog_credentials.each do |username, credentials|
+          if user_login = @users_passwords[username]
+            f << <<-EOS
+## #{user_login[:username]}
+
+* Sign-in URL: #{user_login[:url]}
+* Username: #{user_login[:username]}
+* Password: #{user_login[:password]}
+
+            EOS
+          end
+        end
+        say "Stored all user passwords: #{File.expand_path('students-console-passwords.md')}"
+      end
+    end
+  end
+
+  desc "delete-students", "Delete temporary student IAM accounts"
+  common_options
+  def delete_students
+    load_and_verify_options
+    @io_semaphore = Mutex.new
+
+    Parallel.each(fog_credentials, in_threads: fog_credentials.size) do |username, credentials|
+      begin
+        iam = Fog::AWS::IAM.new(credentials)
+        delete_user(iam, username)
+        @io_semaphore.synchronize do
+          user_say username, "Deleted user", :green
+        end
+      rescue Fog::AWS::IAM::NotFound
+        @io_semaphore.synchronize do
+          user_say username, "Does not exist", :red
+        end
+      rescue => e
+        @io_semaphore.synchronize do
+          user_say username, e.message, :red
+        end
+      end
+    end
+  end
+
+  desc "clean-accounts", "Clean out all VMs, disk, elastic IPs, AMIs, VPCs from student accounts"
+  common_options
+  def clean_accounts
+    load_and_verify_options
+    @io_semaphore = Mutex.new
+
+    # Double check before unleashing devastation
+    unless yes?("Do you really want to terminate all instances, disk, IPs, networks etc?", :red)
+      say "Phew!", :green
+      exit 1
+    end
+    Parallel.each(fog_credentials, in_threads: fog_credentials.size) do |account, credentials|
+      all_regions = aws_regions(false)
+      Parallel.each(all_regions, in_threads: all_regions.size) do |aws_region|
+        compute = Fog::Compute::AWS.new(credentials.merge(region: aws_region))
+        destroy_everything(account, aws_region, compute)
+      end
+    end
+  end
+
+  private
+  def load_and_verify_options
+    @fog_file = options["fog_file"]
+    unless File.exists?(@fog_file)
+      say "File #{@fog_file} does not exist", :red
+      exit 1
+    end
+    @fog_credentials = YAML.load_file(@fog_file)
+    if !@fog_credentials.is_a?(Hash) || @fog_credentials.first.is_a?(Hash)
+      say "File #{@fog_file} does not match a .fog format (Hash of Hashes)", :red
+      exit 1
+    end
+
+    if options["only"]
+      only_specific_keys = options["only"].split(',')
+      @fog_credentials = fog_credentials.keep_if { |key, value| only_specific_keys.include?(key.to_s) }
+    end
+    # TODO: filter @fog_credentials by filter/ignore list
+  end
+
+  # generated via http://awspolicygen.s3.amazonaws.com/policygen.html
+  # Effect	Action   Resource	         Conditions
+  # Allow	  ec2:*	   arn:aws:ec2:*:*:*	 None
+  # Allow	  s3:*	   arn:aws:s3:::*	     None
+  def iam_key_policy(arn)
+    {
+      'Statement' => [
+        'Effect' => 'Allow',
+        'Action' => 'iam:*AccessKey*',
+        'Resource' => arn
+      ]
+    }
+  end
+
+  def iam_student_policy
+    {
+      "Statement" => [
+        {
+          "Effect" => "Allow",
+          "Action" => "*",
+          "Resource" => "*"
+        },
+      ]
+    }
+  end
+
+  def generate_password
+    "starkandwayne"
+  end
+
+  def user_say(username, *args)
+    say "[#{username}] "
+    say *args
+  end
+
+  def user_say_region(username, region, *args)
+    say "[#{username}] [#{region}] "
+    say *args
+  end
+
+  def create_student_user(account, admin_credentials, signin_urls)
+    unless account_signin_url = signin_urls[account]
+      @io_semaphore.synchronize do
+        user_say account, "Admin account #{account} missing from #{options[:signin_urls]}, skipping", :red
+      end
+      return
+    end
+
+    begin
+      iam = Fog::AWS::IAM.new(admin_credentials)
+
+      # create user with same name as we externally refer to the account; e.g. student15
+      username = account
+
+      begin
+        user_response = iam.create_user(username)
+      rescue Fog::AWS::IAM::EntityAlreadyExists
+        @io_semaphore.synchronize do
+          user_say username, "User exists, deleting..."
+        end
+
+        delete_user(iam, username)
+        user_response = iam.create_user(username)
+      rescue => e
+        @io_semaphore.synchronize do
+          user_say username, e.message, :red
+        end
+      end
+
+      @io_semaphore.synchronize do
+        user_say username, "Created user #{username}", :green
+      end
+      key_response  = iam.create_access_key('UserName' => username)
+      access_key_id     = key_response.body['AccessKey']['AccessKeyId']
+      secret_access_key = key_response.body['AccessKey']['SecretAccessKey']
+
+      @io_semaphore.synchronize do
+        user_say username, "Created API access key", :green
+        user_say username, "TODO: generated and download SSH public key", :yellow
+      end
+
+      password = generate_password
+      iam.create_login_profile(username, password)
+      @io_semaphore.synchronize do
+        user_say username, "Created login password", :green
+      end
+
+      arn = user_response.body['User']['Arn']
+      iam.put_user_policy(username, 'UserKeyPolicy', iam_key_policy(arn))
+      iam.put_user_policy(username, 'UserAllPolicy', iam_student_policy)
+      @io_semaphore.synchronize do
+        user_say username, "Created user policies", :green
+      end
+
+      user_credentials = {
+        aws_access_key_id: access_key_id,
+        aws_secret_access_key: secret_access_key
+      }
+      begin
+        user_compute = Fog::Compute::AWS.new(user_credentials)
+        server_count = user_compute.servers.size
+        @io_semaphore.synchronize do
+          user_say username, "Verify credentials: "
+          say "OK ", :green
+          say "(#{server_count} vms)"
+        end
+      rescue => e
+        @io_semaphore.synchronize do
+          user_say username, "Verify credentials: "
+          say e.message, :red
+        end
+      end
+
+      @users_credentials[username.to_sym] = user_credentials
+      user_login = {
+        password: password,
+        username: username.to_s,
+        url: account_signin_url
+      }
+      @users_passwords[username] = user_login
+
+      write_fog_file(username, user_credentials)
+      write_password_file(account_signin_url, user_login)
+    rescue => e
+      @io_semaphore.synchronize do
+        say "#{e.class}: #{e.message}", :red
+      end
+    end
+
+  end
+
+  def delete_user(iam, username)
+    access_keys_reponse = iam.list_access_keys('UserName' => username)
+    access_keys_reponse.body['AccessKeys'].each do |key|
+      user_response = iam.delete_access_key(key['AccessKeyId'], 'UserName' => username)
+    end
+    @io_semaphore.synchronize do
+      user_say username, "Deleted access keys", :yellow
+    end
+
+    begin
+      iam.delete_login_profile(username)
+      @io_semaphore.synchronize do
+        user_say username, "Deleted user login profile", :yellow
+      end
+    rescue Fog::AWS::IAM::NotFound
+    end
+
+    user_policies_reponse = iam.list_user_policies(username)
+    user_policies_reponse.body['PolicyNames'].each do |policy_name|
+      iam.delete_user_policy(username, policy_name)
+    end
+    @io_semaphore.synchronize do
+      user_say username, "Deleted user policies", :yellow
+    end
+
+    user_response = iam.delete_user(username)
+    @io_semaphore.synchronize do
+      user_say username, "Deleted user", :yellow
+    end
+  end
+
+  def write_fog_file(username, user_credentials)
+    FileUtils.mkdir_p(username.to_s)
+    File.open(File.join(username.to_s, "fog-api.yml"), "w") do |f|
+      f << {
+        default: user_credentials
+      }.to_yaml
+    end
+    @io_semaphore.synchronize do
+      user_say username, "Created fog-api.yml", :green
+    end
+  end
+
+  def write_password_file(account_signin_url, user_login)
+    username = user_login[:username]
+    FileUtils.mkdir_p(username)
+    File.open(File.join(username, "console-passwords.md"), "w") do |f|
+      f << <<-EOS
+# #{username}
+
+* Sign-in URL: #{user_login[:url]}
+* Username: #{username}
+* Password: #{user_login[:password]}
+      EOS
+    end
+    @io_semaphore.synchronize do
+      user_say username, "Created console-passwords.md", :green
+    end
+
+  end
+
+  def destroy_everything(account, aws_region, compute)
+    # First, destroy instances
+    servers = compute.servers
+    original_servers_count = servers.size
+    if original_servers_count > 0
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "Destroying #{original_servers_count} instances"
+      end
+      Parallel.each(servers, in_threads: servers.size) do |server|
+        @io_semaphore.synchronize do
+          user_say_region account, aws_region, "Destroying #{server.id}"
+        end
+        server.destroy
+        server.wait_for { state == "terminated" }
+      end
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "Destroyed #{original_servers_count} instances"
+      end
+    else
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "No instances to destroy"
+      end
+    end
+
+    # Destroy elastic IPs
+    ips = compute.addresses
+    ip_count = ips.size
+    if ip_count > 0
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "Destroying #{ip_count} IPs"
+      end
+      Parallel.each(ips, in_threads: ip_count) do |ip|
+        @io_semaphore.synchronize do
+          user_say_region account, aws_region, "Destroying #{ip.public_ip}"
+        end
+        ip.destroy
+      end
+    else
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "No IP addresses to destroy"
+      end
+    end
+
+    # Destroy elastic IPs
+    ips = compute.addresses
+    ip_count = ips.size
+    if ip_count > 0
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "Destroying #{ip_count} IPs"
+      end
+      Parallel.each(ips, in_threads: ip_count) do |ip|
+        @io_semaphore.synchronize do
+          user_say_region account, aws_region, "Destroying #{ip.public_ip}"
+        end
+        ip.destroy
+      end
+    else
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "No IP addresses to destroy"
+      end
+    end
+
+    # Destroy VPC security groups
+    sg = compute.security_groups.select {|v| v.vpc_id}
+    if sg.size > 0
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "Destroying #{sg.size} VPC security groups"
+      end
+      Parallel.each(sg, in_threads: sg.size) do |sg|
+        @io_semaphore.synchronize do
+          user_say_region account, aws_region, "Destroying #{sg.name}"
+        end
+        begin
+          sg.destroy
+        rescue Fog::Compute::AWS::Error
+          # quietly ignore SGs we can't delete anyway
+        rescue => e
+          user_say_region account, aws_region, e.message, :red
+        end
+      end
+    else
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "No VPC security groups to destroy"
+      end
+    end
+
+    # Destroy subnets
+    subnets = compute.subnets
+    subnet_count = subnets.size
+    if subnet_count > 0
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "Destroying #{subnet_count} subnets"
+      end
+      Parallel.each(subnets, in_threads: subnet_count) do |subnet|
+        @io_semaphore.synchronize do
+          user_say_region account, aws_region, "Destroying #{subnet.subnet_id} (#{subnet.cidr_block})"
+        end
+        subnet.destroy
+      end
+    else
+      @io_semaphore.synchronize do
+        user_say_region account, aws_region, "No subnets to destroy"
+      end
+    end
+
+    # TODO: detach Internet Gtw from VPC
+    # TODO: delete IG
+
+
+    # TODO: figure out how to delete route tables; perhaps detact them first?
+    # rts = compute.route_tables
+    # @io_semaphore.synchronize do
+    #   user_say_region account, aws_region, "Destroying #{rts.size} Route Tables"
+    # end
+    # retry_rts = ThreadSafe::Array.new
+    # Parallel.each(rts, in_threads: rts.size) do |rt|
+    #   @io_semaphore.synchronize do
+    #     user_say_region account, aws_region, "Destroying #{rt.id}"
+    #   end
+    #   begin
+    #     rt.routes.each do |route|
+    #       begin
+    #         compute.delete_route(rt.id, route["destinationCidrBlock"])
+    #       rescue InvalidParameterValue
+    #         # quietly ignore local routes that are implicitly deleted when we destroy rt
+    #       end
+    #     end
+    #     rt.destroy
+    #   rescue
+    #     retry_rts << rt
+    #   end
+    # end
+    #
+    # Parallel.each(retry_rts, in_threads: retry_rts.size) do |rt|
+    #   @io_semaphore.synchronize do
+    #     user_say_region account, aws_region, "Trying again to destroy #{rt.id}"
+    #   end
+    #   begin
+    #     rt.routes.each do |route|
+    #       begin
+    #         compute.delete_route(rt.id, route["destinationCidrBlock"])
+    #       rescue InvalidParameterValue
+    #         # quietly ignore local routes that are implicitly deleted when we destroy rt
+    #       end
+    #     end
+    #     rt.destroy
+    #   rescue => e
+    #     user_say_region account, aws_region, e.message, :red
+    #   end
+    # end
+    #
+    # vpcs = compute.vpcs
+    # original_vpc_count = vpcs.size
+    # @io_semaphore.synchronize do
+    #   user_say_region account, aws_region, "Destroying #{original_vpc_count} VPCs"
+    # end
+    # Parallel.each(vpcs, in_threads: vpcs.size) do |vpc|
+    #   @io_semaphore.synchronize do
+    #     user_say_region account, aws_region, "Destroying #{vpc.id} (#{vpc.cidr_block})"
+    #   end
+    #   begin
+    #     vpc.destroy
+    #   rescue => e
+    #     user_say_region account, aws_region, e.message, :red
+    #   end
+    # end
+  end
+
+  def aws_regions(common_only=true)
+    if common_only
+      ["us-east-1", "us-west-2"]
+    else
+      ["eu-central-1", "sa-east-1", "ap-northeast-1",
+      "eu-west-1", "us-east-1", "us-west-1", "us-west-2",
+      "ap-southeast-2", "ap-southeast-1"]
+    end
+  end
+
+  # returns { servers: num-of-servers-across-regions }
+  def account_summary(credentials)
+    region_server_summary = ThreadSafe::Hash.new
+    Parallel.each(aws_regions, in_threads: aws_regions.size) do |aws_region|
+      compute = Fog::Compute::AWS.new(credentials.merge(region: aws_region))
+      count = compute.servers.select {|s| s.state != "terminated" }.size
+      region_server_summary[aws_region] = count
+    end
+    summary = {}
+    summary[:servers] = region_server_summary.inject(0) do |count, pair|
+      region, servers = pair
+      count + servers
+    end
+    summary
+  end
+end

data/lib/aws_student_accounts/version.rb

@@ -0,0 +1,3 @@
+module AwsStudentAccounts
+  VERSION = "0.1.0"
+end

data/spec/app_spec.rb

@@ -0,0 +1,2 @@
+describe AwsStudentAccounts::App do
+end

data/spec/fixtures/aws.yml

@@ -0,0 +1,7 @@
+---
+:student1:
+  :aws_access_key_id: STUDENT1KEY
+  :aws_secret_access_key: STUDENT1SECRET
+:student2:
+  :aws_access_key_id: STUDENT2KEY
+  :aws_secret_access_key: STUDENT2SECRET

data/spec/spec_helper.rb

@@ -0,0 +1,85 @@
+# Copyright (c) 2012-2013 Stark & Wayne, LLC
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require "rspec/core"
+require "aws_student_accounts"
+
+# for the #sh helper
+require "rake"
+require "rake/file_utils"
+
+# load all files in spec/support/* (but not lower down)
+Dir[File.dirname(__FILE__) + '/support/*'].each do |path|
+  require path unless File.directory?(path)
+end
+
+def spec_fixture(filename)
+  File.expand_path("../fixtures/#{filename}", __FILE__)
+end
+
+def files_match(filename, expected_filename)
+  file = File.read(filename)
+  expected_file = File.read(expected_filename)
+  expect(file).to eq(expected_file)
+end
+
+def yaml_files_match(filename, expected_filename)
+  yaml = YAML.load_file(filename)
+  expected_yaml = YAML.load_file(expected_filename)
+  expect(yaml).to eq(expected_yaml)
+end
+
+def setup_home_dir
+  FileUtils.rm_rf(home_dir)
+  FileUtils.mkdir_p(home_dir)
+  ENV['HOME'] = home_dir
+end
+
+def setup_work_dir
+  FileUtils.mkdir_p(work_dir)
+  FileUtils.chdir(work_dir)
+end
+
+def work_dir
+  File.join(home_dir)
+end
+
+def home_dir
+  File.expand_path("../../tmp/home", __FILE__)
+end
+
+# returns the file path to a file
+# in the fake $HOME folder
+def home_file(*path)
+  File.join(ENV['HOME'], *path)
+end
+
+# returns the file path to a file
+# in the fake ~/workspace/deployments/microbosh folder
+def work_file(*path)
+  File.join(work_dir, *path)
+end
+
+RSpec.configure do |c|
+  c.before(:each) do
+    setup_home_dir
+    setup_work_dir
+  end
+
+  c.color = true
+end
+
+def get_tmp_file_path(content)
+  tmp_file = File.open(File.join(Dir.mktmpdir, "tmp"), "w")
+  tmp_file.write(content)
+  tmp_file.close
+
+  tmp_file.path
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: aws_student_accounts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dr Nic Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manage student AWS accounts in bulk
+email:
+- drnicwilliams@gmail.com
+executables:
+- aws_student_accounts
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- aws_student_accounts.gemspec
+- bin/aws_student_accounts
+- lib/aws_student_accounts.rb
+- lib/aws_student_accounts/app.rb
+- lib/aws_student_accounts/version.rb
+- spec/app_spec.rb
+- spec/fixtures/aws.yml
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Manage student AWS accounts in bulk
+test_files:
+- spec/app_spec.rb
+- spec/fixtures/aws.yml
+- spec/spec_helper.rb