dev-lxc 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd80876c8a3bc57a8b947f054b16dff20ec26843
-  data.tar.gz: 9fcab6eaf86c32e326474bfc8f8e28a3ff2e0a46
+  metadata.gz: 79fba00eb009b9b2fcf9065f5607c3fab54de07d
+  data.tar.gz: 7161cfde69c348d86e8d3e52756ed71ba28cb938
 SHA512:
-  metadata.gz: a01dabcd2f3cbba5fe3fece181bf53d6fd36cdeb9810f9b02735fd5378bcf313630578355573785a804d82c700e15338f417bbd7544c67e862c89eb66beb9ec7
-  data.tar.gz: 726b7161383db28d2bac0a5e1cb7faf152024fc3c6ac2b529dbd16ce6786e9d08573fa660e2273e3e31418c0e6628568f620af4fe06fcceef6a276fa6324f410
+  metadata.gz: 59ead33f36b39cb1c0ad90a0a98c89ac963da70354591157227d5b2094449c5a26f3e93fa74c9a5c50192bb489171e86ca90a9e936d73382c70b42c9dd82a030
+  data.tar.gz: 8d5aae0290ebe546c67af627aa271fa28acc3cebfd2c93d80bbb52a284e9081244b5d28fc0961b2230ab260fd41a85c2945ac6c6556c8f09c36ae285118f4a5b

data/README.md

@@ -63,6 +63,18 @@ Run `gem update dev-lxc` inside the Vagrant VM platform to ensure you have the l
 
 ## Usage
 
+### Display Help
+
+```
+dev-lxc help
+
+dev-lxc -h
+
+dev-lxc --help
+
+dev-lxc help <subcommand>
+```
+
 ### Shorter Commands are Faster (to type that is :)
 
 The dev-lxc-platform's root user's `~/.bashrc` file has aliased `dl` to `dev-lxc` for ease of use but
@@ -73,23 +85,29 @@ You only have to type enough of a `dev-lxc` subcommand to make it unique.
 The following commands are equivalent:
 
 ```
-dev-lxc cluster init standalone > dev-lxc.yml
-dl cl i standalone > dev-lxc.yml
+dev-lxc init standalone > dev-lxc.yml
+dl i standalone > dev-lxc.yml
 ```
 
 ```
-dev-lxc cluster start
-dl cl start
+dev-lxc start
+dl start
+
+# if no subcommand is given then `start` will be called by default
+# and any arguments will be passed to the `start` subcommand
+# so both of the following commands will start all servers
+dev-lxc
+dl
 ```
 
 ```
-dev-lxc cluster status
-dl cl stat
+dev-lxc status
+dl stat
 ```
 
 ```
-dev-lxc cluster destroy
-dl cl d
+dev-lxc destroy
+dl d
 ```
 
 ### Create and Manage a Cluster
@@ -107,7 +125,7 @@ Be sure you configure the
 [mounts and packages entries](https://github.com/jeremiahsnapp/dev-lxc#cluster-config-files)
 appropriately.
 
-	dev-lxc cluster init tier > dev-lxc.yml
+	dev-lxc init tier > dev-lxc.yml
 
 Uncomment the Analytics server section in `dev-lxc.yml` if you want it to be built.
 
@@ -118,7 +136,7 @@ Starting the cluster the first time takes awhile since it has a lot to build.
 The tool automatically creates snapshot clones at appropriate times so future
 creation of the cluster's servers is very quick.
 
-	dev-lxc cluster start
+	dev-lxc start
 
 A test org, user, knife.rb and keys are automatically created in
 the bootstrap backend server in `/root/chef-repo/.chef` for testing purposes.
@@ -131,16 +149,16 @@ org and user.
 
 Run the following command to see the status of the cluster.
 
-    dev-lxc cluster status
+    dev-lxc status
 
 This is an example of the output.
 
 ```
 Cluster is available at https://chef.lxc
 Analytics is available at https://analytics.lxc
-         be-tier.lxc     running         10.0.3.203
-        fe1-tier.lxc     running         10.0.3.204
-  analytics-tier.lxc     running         10.0.3.206
+         tier-be.lxc     running         10.0.3.203
+        tier-fe1.lxc     running         10.0.3.204
+  tier-analytics.lxc     running         10.0.3.206
 ```
 
 [https://chef.lxc](https://chef.lxc) resolves to the frontend.
@@ -149,7 +167,7 @@ Analytics is available at https://analytics.lxc
 
 Create a local chef-repo with appropriate knife.rb and pem files.
 
-    dev-lxc cluster chef-repo
+    dev-lxc chef-repo
 
 Now you can easily use knife to access the cluster.
 
@@ -163,68 +181,78 @@ Clones of the servers as they existed immediately after initial installation, co
 test org and user creation are available so you can destroy the cluster and "rebuild" it within
 seconds effectively starting with a clean slate very easily.
 
-    dev-lxc cluster destroy
-	dev-lxc cluster start
+    dev-lxc destroy
+	dev-lxc start
 
 #### Stop and start the cluster
 
-	dev-lxc cluster stop
-	dev-lxc cluster start
+	dev-lxc stop
+	dev-lxc start
 
 #### Backdoor access to each server's filesystem
 
 The abspath subcommand can be used to prepend each server's rootfs path to a particular file.
 
-When using `dev-lxc cluster abspath` only results for actual Chef Servers will be returned.
-If an Analytics server is described in `dev-lcx.yml` it will be ignored.
-
-For example, you can use the following command to edit each server's chef-server.rb file without
-logging into the containers.
+For example, you can use the following command to edit the backend and frontend servers' chef-server.rb
+file without logging into the containers.
 
-    emacs $(dev-lxc cluster abspath /etc/opscode/chef-server.rb)
+    emacs $(dev-lxc abspath 'be|fe' /etc/opscode/chef-server.rb)
 
 #### Run arbitrary commands in each server
 
-After modifying the chef-server.rb you could use the run_command subcommand to tell each server
-to run `chef-server-ctl reconfigure`.
+After modifying the chef-server.rb you could use the run_command subcommand to tell the backend and
+frontend servers to run `chef-server-ctl reconfigure`.
 
-When using `dev-lxc cluster run_command` the command will only be run in actual Chef Servers.
-If an Analytics server is described in `dev-lcx.yml` it will be ignored.
-
-    dev-lxc cluster run_command 'chef-server-ctl reconfigure'
+    dev-lxc run_command 'be|fe' 'chef-server-ctl reconfigure'
 
 #### Destroy cluster
 
 Use the following command to destroy the cluster's servers and also destroy their unique and shared
 base containers if you want to build them from scratch.
 
-    dev-lxc cluster destroy -u -s
+    dev-lxc destroy -u -s
 
 #### Use commands against a specific server
-You can also run most of these commands against individual servers by using the server subcommand.
+You can also run most of these commands against a set of servers by specifying a pattern that matches
+a set of server names.
+
+    dev-lxc <subcommand> [pattern]
 
-    dev-lxc server ...
+For example, to only start the backend and frontend servers named `tier-be.lxc` and `tier-fe1.lxc`
+you can run the following command.
+
+    dev-lxc start 'be|fe'
 
 ### Using the dev-lxc library
 
-dev-lxc can also be used as a library.
+dev-lxc cli interface can be used as a library.
+
+	require 'dev-lxc/cli'
+
+	ARGV = [ 'start' ]         # start all servers
+	DevLXC::CLI::DevLXC.start
+
+	ARGV = [ 'status' ]        # show status of all servers
+	DevLXC::CLI::DevLXC.start
+
+	ARGV = [ 'run_command', 'uptime' ]   # run `uptime` in all servers
+	DevLXC::CLI::DevLXC.start
+
+	ARGV = [ 'destroy' ]       # destroy all servers
+	DevLXC::CLI::DevLXC.start
+
+dev-lxc itself can also be used as a library
 
     require 'yaml'
 	require 'dev-lxc'
-	config = YAML.load(IO.read('dev-lxc.yml'))
-	cluster = DevLXC::ChefCluster.new(config)
-	cluster.start
-	cluster.status
-	cluster.run_command("uptime")
-	server = DevLXC::ChefServer.new("fe1-tier.lxc", config)
-	server.stop
-	server.status
-	cluster.status
-	server.start
-	cluster.status
-	server.run_command("chef-server-ctl reconfigure")
-	cluster.destroy
-	cluster.status
+
+    config = YAML.load(IO.read('dev-lxc.yml'))
+    server = DevLXC::ChefServer.new("tier-fe1.lxc", config)
+
+	server.start               # start tier-fe1.lxc
+	server.status              # show status of tier-fe1.lxc
+	server.run_command("chef-server-ctl reconfigure")  # run command in tier-fe1.lxc
+	server.stop                # stop tier-fe1.lxc
 
 ## Cluster Config Files
 
@@ -232,9 +260,9 @@ dev-lxc uses a YAML configuration file named `dev-lxc.yml` to define a cluster.
 
 The following command generates sample config files for various cluster topologies.
 
-	dev-lxc cluster init
+	dev-lxc init
 
-`dev-lxc cluster init tier > dev-lxc.yml` creates a `dev-lxc.yml` file with the following content:
+`dev-lxc init tier > dev-lxc.yml` creates a `dev-lxc.yml` file with the following content:
 
     platform_container: p-ubuntu-1404
     topology: tier
@@ -249,17 +277,17 @@ The following command generates sample config files for various cluster topologi
     #  push-jobs-server: /dev-shared/chef-packages/push-jobs-server/opscode-push-jobs-server_1.1.6-1_amd64.deb
     #  analytics: /dev-shared/chef-packages/analytics/opscode-analytics_1.1.1-1_amd64.deb
     servers:
-      be-tier.lxc:
+      tier-be.lxc:
         role: backend
         ipaddress: 10.0.3.203
         bootstrap: true
-      fe1-tier.lxc:
+      tier-fe1.lxc:
         role: frontend
         ipaddress: 10.0.3.204
-    #  fe2-tier.lxc:
+    #  tier-fe2.lxc:
     #    role: frontend
     #    ipaddress: 10.0.3.205
-    #  analytics-tier.lxc:
+    #  tier-analytics.lxc:
     #    role: analytics
     #    ipaddress: 10.0.3.206
 
@@ -298,10 +326,10 @@ The following is an example of managing multiple clusters while still avoiding s
 each cluster's config file.
 
 	mkdir -p ~/clusters/{clusterA,clusterB}
-	dev-lxc cluster init tier > ~/clusters/clusterA/dev-lxc.yml
-	dev-lxc cluster init standalone > ~/clusters/clusterB/dev-lxc.yml
-	cd ~/clusters/clusterA && dev-lxc cluster start  # starts clusterA
-	cd ~/clusters/clusterB && dev-lxc cluster start  # starts clusterB
+	dev-lxc init tier > ~/clusters/clusterA/dev-lxc.yml
+	dev-lxc init standalone > ~/clusters/clusterB/dev-lxc.yml
+	cd ~/clusters/clusterA && dev-lxc start  # starts clusterA
+	cd ~/clusters/clusterB && dev-lxc start  # starts clusterB
 
 ### Maintain Uniqueness Across Multiple Clusters
 
@@ -320,10 +348,10 @@ more clusters you have to maintain uniqueness across the YAML config files for t
     If cluster B is started with the same `api_fqdn` as an already running cluster A, then cluster B
 	will overwrite cluster A's DNS resolution of `api_fqdn`.
 
-    It is easy to provide uniqueness. For example, you can use the following command to replace `-tier`
-	with `-1234` in a tier cluster's config.
+    It is easy to provide uniqueness. For example, you can use the following command to replace `.lxc`
+	with `-1234.lxc` in a cluster's config.
 
-        sed -i 's/-tier/-1234/' dev-lxc.yml
+        sed -i 's/\.lxc/-1234.lxc/' dev-lxc.yml
 
 * IP Addresses
 
@@ -373,7 +401,7 @@ During a cluster build process the base containers that get created fall into th
 
     `DevLXC::ChefServer#create_base_server` controls the creation of a shared base container.
 
-    Chef packages that are common to all servers in a Chef cluster, such as Chef server,
+    Chef packages that are common to all servers in a Chef cluster, such as chef-server-core,
 	opscode-reporting and opscode-push-jobs-server are installed using `dpkg` or `rpm`.
 
     Note the manage package will not be installed at this point since it is not common to all
@@ -407,15 +435,12 @@ During a cluster build process the base containers that get created fall into th
 
 ### Destroying Base Containers
 
-When using `dev-lxc cluster destroy` to destroy an entire Chef cluster or `dev-lxc server destroy [NAME]`
-to destroy a single Chef server you have the option to also destroy any or all of the three types
-of base containers associated with the cluster or server.
-
-Either of the following commands will list the options available.
+When using `dev-lxc destroy` to destroy servers you have the option to also destroy any or all of
+the three types of base containers associated with the servers.
 
-    dev-lxc cluster help destroy
+The following command will list the options available.
 
-    dev-lxc server help destroy
+    dev-lxc help destroy
 
 Of course, you can also just use the standard LXC commands to destroy any container.
 

data/lib/dev-lxc/chef-cluster.rb

@@ -35,18 +35,6 @@ module DevLXC
       chef_servers
     end
 
-    def status
-      puts "Cluster is available at https://#{@api_fqdn}"
-      puts "Analytics is available at https://#{@analytics_fqdn}" if @analytics_fqdn
-      chef_servers.each { |cs| cs.status }
-    end
-
-    def abspath(rootfs_path)
-      abspath = Array.new
-      chef_servers.each { |cs| abspath << cs.abspath(rootfs_path) unless cs.role == 'analytics' }
-      abspath.compact
-    end
-
     def chef_repo
       if @topology == "open-source"
         puts "Unable to create a chef-repo for an Open Source Chef Server"
@@ -81,29 +69,6 @@ knife[:chef_repo_path] = Dir.pwd
       end
     end
 
-    def run_command(command)
-      chef_servers.each { |cs| cs.run_command(command) unless cs.role == 'analytics' }
-    end
-
-    def start
-      puts "Starting cluster"
-      chef_servers.each { |cs| cs.start }
-    end
-
-    def stop
-      puts "Stopping cluster"
-      chef_servers.reverse_each { |cs| cs.stop }
-    end
-
-    def destroy
-      puts "Destroying cluster"
-      chef_servers.reverse_each { |cs| cs.destroy }
-    end
-
-    def destroy_container(type)
-      chef_servers.each { |cs| cs.destroy_container(type) }
-    end
-
     def chef_server_config
       chef_server_config = %Q(api_fqdn "#{@api_fqdn}"\n)
       if @topology == 'tier'

data/lib/dev-lxc/cli.rb

@@ -3,7 +3,8 @@ require 'dev-lxc'
 require 'thor'
 
 module DevLXC::CLI
-  class Cluster < Thor
+  class DevLXC < Thor
+
     no_commands{
       def get_cluster(config_option)
         config = "dev-lxc.yaml" if File.exists?("dev-lxc.yaml")
@@ -12,8 +13,24 @@ module DevLXC::CLI
         raise "A cluster config file must be provided" if config.nil?
         ::DevLXC::ChefCluster.new(YAML.load(IO.read(config)))
       end
+
+      def match_pattern(pattern)
+        get_cluster(options[:config]).chef_servers.select { |cs| cs.server.name =~ /#{pattern}/ }
+      end
     }
 
+    desc "create [PLATFORM_CONTAINER_NAME]", "Create a platform container"
+    def create(platform_container_name=nil)
+      platform_container_names = %w(p-ubuntu-1204 p-ubuntu-1404 p-centos-5 p-centos-6)
+      if platform_container_name.nil? || ! platform_container_names.include?(platform_container_name)
+        platform_container_names_with_index = platform_container_names.map.with_index{ |a, i| [i+1, *a]}
+        print_table platform_container_names_with_index
+        selection = ask("Which platform container do you want to create?", :limited_to => platform_container_names_with_index.map{|c| c[0].to_s})
+        platform_container_name = platform_container_names[selection.to_i - 1]
+      end
+      ::DevLXC.create_platform_container(platform_container_name)
+    end
+
     desc "init [TOPOLOGY]", "Provide a cluster config file"
     def init(topology=nil)
       topologies = %w(open-source standalone tier)
@@ -26,16 +43,26 @@ module DevLXC::CLI
       puts IO.read("#{File.dirname(__FILE__)}/../../files/configs/#{topology}.yml")
     end
 
-    desc "status", "Show status of all servers"
+    desc "status", "Show status of servers"
     option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def status
-      get_cluster(options[:config]).status
+    def status(pattern=nil)
+      config = "dev-lxc.yaml" if File.exists?("dev-lxc.yaml")
+      config = "dev-lxc.yml" if File.exists?("dev-lxc.yml")
+      config = options[:config] unless options[:config].nil?
+      raise "A cluster config file must be provided" if config.nil?
+      cluster_config = YAML.load(IO.read(config))
+
+      puts "Cluster is available at https://#{cluster_config['api_fqdn']}"
+      puts "Analytics is available at https://#{cluster_config['analytics_fqdn']}" if cluster_config['analytics_fqdn']
+      match_pattern(pattern).each { |cs| cs.status }
     end
 
-    desc "abspath [ROOTFS_PATH]", "Returns the absolute path to a file in each Chef Server (not in an Analytics server)"
+    desc "abspath [ROOTFS_PATH]", "Returns the absolute path to a file in each server"
     option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def abspath(rootfs_path)
-      puts get_cluster(options[:config]).abspath(rootfs_path).join(" ")
+    def abspath(pattern=nil, rootfs_path)
+      abspath = Array.new
+      match_pattern(pattern).map { |cs| abspath << cs.abspath(rootfs_path) }
+      puts abspath.compact.join(" ")
     end
 
     desc "chef-repo", "Creates a chef-repo in the current directory using files from the cluster's backend /root/chef-repo"
@@ -44,110 +71,44 @@ module DevLXC::CLI
       get_cluster(options[:config]).chef_repo
     end
 
-    desc "run_command [COMMAND]", "Runs a command in each Chef Server (not in an Analytics server)"
+    desc "run_command [COMMAND]", "Runs a command in each server"
     option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def run_command(command)
-      get_cluster(options[:config]).run_command(command)
+    def run_command(pattern=nil, command)
+      match_pattern(pattern).each { |cs| cs.run_command(command) }
     end
 
-    desc "start", "Start all servers"
+    desc "start", "Start servers"
     option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def start
-      get_cluster(options[:config]).start
+    def start(pattern=nil)
+      match_pattern(pattern).each { |cs| cs.start }
     end
 
-    desc "stop", "Stop all servers"
-    option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def stop
-      get_cluster(options[:config]).stop
+    # make `start` the default subcommand and pass any arguments to it
+    default_task :start
+    def method_missing(method, *args)
+      args = ["start", method.to_s] + args
+      DevLXC.start(args)
     end
 
-    desc "destroy", "Destroy all servers"
+    desc "stop", "Stop servers"
     option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    option :unique, :aliases => "-u", :type => :boolean, :desc => "Also destroy the unique containers"
-    option :shared, :aliases => "-s", :type => :boolean, :desc => "Also destroy the shared container"
-    option :platform, :aliases => "-p", :type => :boolean, :desc => "Also destroy the platform container"
-    def destroy
-      cluster = get_cluster(options[:config])
-      cluster.destroy
-      cluster.destroy_container(:unique) if options[:unique]
-      cluster.destroy_container(:shared) if options[:shared]
-      cluster.destroy_container(:platform) if options[:platform]
+    def stop(pattern=nil)
+      match_pattern(pattern).reverse_each { |cs| cs.stop }
     end
-  end
 
-  class Server < Thor
-    no_commands{
-      def get_server(name, config_option)
-        config = "dev-lxc.yaml" if File.exists?("dev-lxc.yaml")
-        config = "dev-lxc.yml" if File.exists?("dev-lxc.yml")
-        config = config_option unless config_option.nil?
-        raise "A cluster config file must be provided" if config.nil?
-        ::DevLXC::ChefServer.new(name, YAML.load(IO.read(config)))
-      end
-    }
-
-    desc "status [NAME]", "Show status of a server"
+    desc "destroy", "Destroy servers"
     option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def status(name)
-      get_server(name, options[:config]).status
-    end
-
-    desc "abspath [NAME] [ROOTFS_PATH]", "Returns the absolute path to a file in a server"
-    option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def abspath(name, rootfs_path)
-      puts get_server(name, options[:config]).abspath(rootfs_path)
-    end
-
-    desc "run_command [NAME] [COMMAND]", "Runs a command in a server"
-    option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def run_command(name, command)
-      get_server(name, options[:config]).run_command(command)
-    end
-
-    desc "start [NAME]", "Start a server"
-    option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def start(name)
-      get_server(name, options[:config]).start
-    end
-
-    desc "stop [NAME]", "Stop a server"
-    option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    def stop(name)
-      get_server(name, options[:config]).stop
-    end
-
-    desc "destroy [NAME]", "Destroy a server"
-    option :config, :aliases => "-c", :desc => "Specify a cluster's YAML config file. ./dev-lxc.yml will be used by default"
-    option :unique, :aliases => "-u", :type => :boolean, :desc => "Also destroy the unique container"
+    option :unique, :aliases => "-u", :type => :boolean, :desc => "Also destroy the unique containers"
     option :shared, :aliases => "-s", :type => :boolean, :desc => "Also destroy the shared container"
     option :platform, :aliases => "-p", :type => :boolean, :desc => "Also destroy the platform container"
-    def destroy(name)
-      server = get_server(name, options[:config])
-      server.destroy
-      server.destroy_container(:unique) if options[:unique]
-      server.destroy_container(:shared) if options[:shared]
-      server.destroy_container(:platform) if options[:platform]
-    end
-  end
-
-  class DevLXC < Thor
-    desc "create [PLATFORM_CONTAINER_NAME]", "Create a platform container"
-    def create(platform_container_name=nil)
-      platform_container_names = %w(p-ubuntu-1204 p-ubuntu-1404 p-centos-5 p-centos-6)
-      if platform_container_name.nil? || ! platform_container_names.include?(platform_container_name)
-        platform_container_names_with_index = platform_container_names.map.with_index{ |a, i| [i+1, *a]}
-        print_table platform_container_names_with_index
-        selection = ask("Which platform container do you want to create?", :limited_to => platform_container_names_with_index.map{|c| c[0].to_s})
-        platform_container_name = platform_container_names[selection.to_i - 1]
+    def destroy(pattern=nil)
+      match_pattern(pattern).reverse_each do |cs|
+        cs.destroy
+        cs.destroy_container(:unique) if options[:unique]
+        cs.destroy_container(:shared) if options[:shared]
+        cs.destroy_container(:platform) if options[:platform]
       end
-      ::DevLXC.create_platform_container(platform_container_name)
     end
 
-    desc "cluster SUBCOMMAND ...ARGS", "Manage cluster"
-    subcommand "cluster", Cluster
-
-    desc "server SUBCOMMAND ...ARGS", "Manage server"
-    subcommand "server", Server
   end
 end

data/lib/dev-lxc/version.rb

@@ -1,3 +1,3 @@
 module DevLXC
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dev-lxc
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Jeremiah Snapp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2015-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler