vikingio 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82673e848156299dbfd0d031352d52d872435620
+  data.tar.gz: cd4dc18085fe19a7794c01d002f0e2789ad84654
+SHA512:
+  metadata.gz: 2f998edb0b94f5ac7fe632f4e2bfa07414e8cf21343aafcb89d1aa449c565b34c9b855adb62208c305a515db7616b286b819337dae8e9772ba1e31bcfc23ec12
+  data.tar.gz: 64bafd179627a05cadf58aff2da768a1891ff998977551bcb195f7e09359230e3661b88ef4cfa7251b86a8cab66895b4f5d42569fa9c5fe0b9c453ded7580606

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Eric Campbell
+
+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,14 @@
+Command Line Toolkit for VikingIO. Sign up at http://www.vikingio.com
+
+Commands:
+
+help -
+login - Authenticate with VikingIO
+logout - Clear your authentication credentials
+create - Create a new VikingIO application
+generate - Generate a skeleton VikingIO application
+link - Link the current directory with an existing VikingIO application
+unlink - Unlink the current directory with it's VikingIO application
+deploy - Deploy your application
+shutdown - Shutdown all production servers
+run - Compile and run your application locally

data/Rakefile

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

data/bin/vikingio

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8                                      
+
+# start up the CLI
+require "vikingio/cli"
+VikingIO::CLI.start(*ARGV)

data/lib/vikingio/cli/client.rb

@@ -0,0 +1,144 @@
+module VikingIO
+  module CLI  
+    module Client          
+      
+      BASE_PATH = "https://www.vikingio.com/api/"   
+      BASE_BUILD_PATH = "http://build1.vikingio.com/"   
+      
+      def self.get_status(user_key, app_key)
+        uri = URI.join(BASE_PATH, "apps/status")
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Get.new(uri.path)
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-app-key'] = app_key      
+        resp = http.request(req)
+        return JSON.parse(resp.body)
+      end
+      
+      def self.deploy_data(user_key, app_key, data_path)
+        uri = URI.join(BASE_BUILD_PATH, "deploy_data")
+        
+        req = Net::HTTP::Post::Multipart.new uri.path, {"file" => UploadIO.new(data_path, "application/octet-stream")}
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(req)
+        end
+      end
+      
+      def self.deploy_servers(user_key, app_key, server_path)
+        uri = URI.join(BASE_BUILD_PATH, "deploy_servers")
+        
+        req = Net::HTTP::Post::Multipart.new uri.path, {"file" => UploadIO.new(server_path, "application/octet-stream")}
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(req)
+        end
+      end  
+      
+      def self.deploy_check(user_key, app_key)
+        uri = URI.join(BASE_BUILD_PATH, "deploy_check")
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Get.new(uri.path)
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key       
+        req['x-vikingio-nodefile'] = VikingIO::CLI.get_node_data.to_json
+        resp = http.request(req)
+        return resp.body
+      end
+      
+      def self.deploy(user_key, app_key)
+        uri = URI.join(BASE_BUILD_PATH, "deploy")
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Get.new(uri.path)
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key       
+        req['x-vikingio-nodefile'] = VikingIO::CLI.get_node_data.to_json
+        resp = http.request(req)
+        return resp.body
+      end
+      
+      def self.request_build_job(user_key, app_key)
+        uri = URI.join(BASE_BUILD_PATH, "start")
+                                        
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Get.new(uri.path)
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key  
+        http.request(req)                                    
+      end     
+      
+      def self.synchronize_file(user_key, app_key, file)
+        uri = URI.join(BASE_BUILD_PATH, "sync")
+        
+        req = Net::HTTP::Post::Multipart.new uri.path, {"file" => UploadIO.new(file, "application/octet-stream"), "build-rfname" => file.gsub(File.join(Dir.pwd, "VikingIO"), "")}
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(req)
+        end
+      end      
+      
+      def self.compile_server(user_key, app_key, app_name)
+        uri = URI.join(BASE_BUILD_PATH, "compile")
+                                        
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Get.new(uri.path)
+        req['x-vikingio-user-key'] = user_key 
+        req['x-vikingio-key'] = app_key  
+        req['x-vikingio-app-name'] = app_name                              
+        resp = http.request(req)
+        
+        puts resp.body
+      end
+        
+      def self.authenticate(email, password)
+        uri = URI.join(BASE_PATH, "auth")
+        
+        response = Net::HTTP.post_form(uri, {"email" => email, "password" => password})                                                                                      
+        
+        return nil if response.code == "403"
+        puts "Unable to reach server." and return nil if response.code == "401"
+                                     
+        json = JSON.parse(response.body)
+        
+        return json["key"]                          
+      end
+      
+      def self.create_app(name)
+        uri = URI.join(BASE_PATH, "apps")
+        
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Post.new(uri.path)
+        req['x-vikingio-user-key'] = VikingIO::CLI.get_netrc_key   
+        req.set_form_data({"name" => name})
+        response = http.request(req)
+        
+        return nil if response.code == "403"
+        puts "Unable to reach server." and return nil if response.code == "401"
+        
+        return JSON.parse(response.body)
+      end
+      
+      def self.create_node(name, app_key) 
+        return nil if name == "" || name == nil
+        
+        uri = URI.join(BASE_PATH, "nodes")
+        
+        http = Net::HTTP.new(uri.host, uri.port)                           
+        req = Net::HTTP::Post.new(uri.path)
+        req['x-vikingio-user-key'] = VikingIO::CLI.get_netrc_key  
+        req['x-vikingio-app-key'] = app_key 
+        req.set_form_data({"name" => name})
+        response = http.request(req)
+        
+        return nil if response.code == "403"
+        puts "Unable to reach server." and return nil if response.code == "401"
+        
+        return JSON.parse(response.body)
+      end
+      
+    end
+  end
+end

data/lib/vikingio/cli/commands.rb

@@ -0,0 +1,467 @@
+module VikingIO
+  module CLI
+    module Commands    
+                                                                       
+      BASE_PATH = "http://build1.vikingio.com/"
+      UNITY_COMPILER_PATH_OSX = "/Applications/Unity/Unity.app/Contents/Frameworks/MonoBleedingEdge/bin/gmcs"
+      UNITY_MONO_PATH_OSX = "/Applications/Unity/Unity.app/Contents/Frameworks/MonoBleedingEdge/bin/mono"  
+      UNITY_MONO_DLL_PATH_OSX = "/Applications/Unity/Unity.app/Contents/Frameworks/MonoBleedingEdge/lib/"
+      TEMPLATES_DIR = File.join(File.dirname(__FILE__), "../../../templates")
+      
+      COMMANDS = [ 
+          ["help", {:short => "", :full => ""}],
+          ["login", {:short => "Authenticate with VikingIO", :full => ""}],
+          ["logout", {:short => "Clear your authentication credentials", :full => ""}],
+          ["create", {:short => "Create a new VikingIO application", :full => "Ex: vikingio create [app-name]"}], 
+          ["generate", {:short => "Generate a VikingIO node", :full => "Ex: vikingio generate node GameServer"}],
+          #["link", {:short => "Link the current directory with an existing VikingIO application", :full => "Ex: vikingio link [app-name]"}],
+          ["unlink", {:short => "Unlink the current directory with it's VikingIO application", :full => "Ex: vikingio unlink"}],
+          #["compile", {:short => "Compile your application on the server.", :full => "Once compiled, your application is ready to deploy."}],
+          ["deploy", {:short => "Deploy your application", :full => "The latest build will be deployed to our cloud infrastructure. [NOTE: Billing will begin immediately after your application is deployed.]"}],
+          #["destroy", {:short => "Destroy all production nodes in the VikingIO cloud", :full => "This will completely shut down and remove all of your production nodes for this application."}],
+          ["run", {:short => "Compile and run your application locally", :full => ""}],
+          #["status", {:short => "Get status of nodes", :full => ""}],
+          #[""]
+      ]                                         
+      
+      def self.run(command, args)   
+        case command
+          when "help"
+            help(args)
+          when "login"
+            login(args) 
+          when "logout"
+            logout(args)
+          when "create"
+            create(args)
+          when "generate"
+            generate(args)
+          when "link"
+            link(args)
+          when "unlink"
+            unlink(args)  
+          when "run"
+            compile_and_run(args)  
+          when "deploy"
+            deploy(args)   
+          #when "compile"
+          #  compile_on_server(args)  
+          when "destroy"
+            destroy(args) 
+          when "status"
+            status(args)
+          else
+            help(args)
+        end
+      end               
+      
+      def self.status(*args) 
+        app_data = VikingIO::CLI.get_app_data
+        user_key = VikingIO::CLI.get_netrc_key
+        puts VikingIO::CLI::Client.get_status(user_key, app_data["key"])
+      end 
+      
+      def self.destroy(*args)
+        
+        puts ""
+        puts "****** WARNING *******"
+        puts "This will shut down all of the server node instances for this application. You will have to re-deploy from scratch."
+        puts ""
+        
+        puts "Proceed? (y/n)" 
+        y_or_n = STDIN.gets.chomp.downcase
+        
+        if ["y", "yes"].include?(y_or_n)
+            
+        else
+          puts "Aborting."
+        end
+        
+      end
+      
+      # def self.compile_on_server(*args)
+      #   args.flatten!
+      #   
+      #   app_data = VikingIO::CLI.get_app_data
+      #   user_key = VikingIO::CLI.get_netrc_key
+      #                                        
+      #   puts "Synchronizing '#{app_data["name"]}' files..." 
+      #   
+      #   VikingIO::CLI::Client.request_build_job(user_key, app_data["key"])
+      #    
+      #   Dir.chdir(File.join(Dir.pwd, "Assets", "VikingIO")) do
+      #     files = Dir.glob("**/**/**").reject {|x| x.start_with?("Client") }.reject {|x| Dir.exist?(x) }.reject {|x| x.end_with?(".meta") }
+      #     files.each do |file|         
+      #       puts file + "..."
+      #       VikingIO::CLI::Client.synchronize_file(user_key, app_data["key"], file)
+      #     end
+      #   end           
+      #   
+      #   puts "Compiling..."
+      #   
+      #   VikingIO::CLI::Client.compile_server(user_key, app_data["key"], app_data["name"])
+      #   
+      #   puts "done."
+      # end     
+                       
+      def self.deploy(*args)
+        args.flatten!
+        
+        app_data = VikingIO::CLI.get_app_data
+        user_key = VikingIO::CLI.get_netrc_key  
+        node_data = VikingIO::CLI.get_node_data
+        
+        tmp_dir = File.join(Dir.tmpdir, "vikingio")    
+        
+        compile = !args.include?("--skip-compilation")
+        compilation_success = true 
+        
+        if args.include?("--check")
+          new_node_ct = VikingIO::CLI::Client.deploy_check(user_key, app_data["key"]).to_i
+          
+          if new_node_ct == 0
+            puts "No new nodes will be created."
+          else
+            puts "#{new_node_ct} new node(s) will be created."
+          end
+          return
+        end    
+        
+        if compile
+          if !self.compile_nodes(tmp_dir, node_data)
+            compilation_success = false 
+          else
+            `cd #{File.join(tmp_dir, "VikingIO")} && tar -zcvf Data.tar.gz Data`                            
+            puts "Deploying data..."
+            VikingIO::CLI::Client.deploy_data(user_key, app_data["key"], File.join(tmp_dir, "VikingIO", "Data.tar.gz"))      
+            `rm -rf #{File.join(tmp_dir, "VikingIO", "Data")}*`   
+            `cd #{File.join(tmp_dir, "VikingIO")} && tar -zcvf #{File.join(tmp_dir, "VikingIO.tar.gz")} .`          
+            puts "Deploying nodes..."
+            VikingIO::CLI::Client.deploy_servers(user_key, app_data["key"], File.join(tmp_dir, "VikingIO.tar.gz"))
+          end
+        end
+        
+        if compilation_success                           
+              
+          new_node_ct = VikingIO::CLI::Client.deploy_check(user_key, app_data["key"]).to_i
+          deploy = true
+          
+          if new_node_ct != 0
+            puts "#{new_node_ct} new node(s) will be created. Continue? (y/n)"
+            y_or_n = STDIN.gets.chomp.downcase
+
+            if !["y", "yes"].include?(y_or_n)
+              deploy = false
+              puts "Aborting."
+            end 
+            
+          end   
+          
+          if deploy
+            puts "Deploying"
+            puts VikingIO::CLI::Client.deploy(user_key, app_data["key"])
+          end
+          
+#          VikingIO::CLI::Client.deploy(user_key, app_data["key"], node_data.to_json)   
+        else
+          puts "Compilation failed. Aborting deploy."
+        end
+      end                       
+      
+      def self.compile_nodes(tmp_dir, node_data)   
+        begin                 
+          puts File.join(tmp_dir, "VikingIO")
+                                                    
+          FileUtils::rm_rf(tmp_dir)
+          FileUtils::mkdir_p(tmp_dir)       
+          FileUtils::cp_r(File.join(Dir.pwd, "Assets", "VikingIO"), tmp_dir)
+          FileUtils::rm_rf(File.join(tmp_dir, "VikingIO", "Client"))
+          
+          meta_files = Dir["#{tmp_dir}/VikingIO/**/*.meta"] 
+          meta_files.each {|x| FileUtils.rm_rf(x) }
+        
+          templates_dir = File.join(File.dirname(__FILE__), "../../../templates")
+          program_template = File.read(File.join(templates_dir, "Program.cs"))
+                                                    
+          app_data = VikingIO::CLI.get_app_data
+                          
+          #dlls_dir = File.join(File.dirname(__FILE__), "../../../dlls")
+          #viking_dll_path = File.join(dlls_dir, "VikingIO.Network.dll") 
+          #FileUtils::cp(viking_dll_path, File.join(tmp_dir, "VikingIO"))
+         
+          cs_files = Dir["#{tmp_dir}/VikingIO/**/*.cs"]     
+        
+          references = Dir["#{tmp_dir}/VikingIO/Server/External/**/*.dll"]  
+          reference_str = references.map{|x| "-reference:#{x}" }.join(" ")      
+                                        
+          log_file = File.join(tmp_dir, "VikingIO", "log")    
+        
+          node_data.each do |node|               
+            @exit_status = nil
+            @exit_msg = ""
+            puts "Compiling '" + node["node_class"] + "' node"     
+            node_class = node["node_class"]
+          
+            program_path = File.join(tmp_dir, "VikingIO", node_class + ".cs")                
+                                                                         
+            puts app_data["name"]
+            File.open(program_path, "w") do |f|
+              f << program_template.gsub("[MODULE_NAME]", node_class).gsub("[APP_NAME]", app_data["name"])
+            end              
+          
+            all_files = cs_files + [program_path] 
+            out_file = "#{tmp_dir}/VikingIO/#{node_class}.exe"  
+
+            Open3.popen3("#{UNITY_COMPILER_PATH_OSX} #{reference_str}  -lib:#{File.join(tmp_dir, "VikingIO", "Server", "External")} -optimize #{all_files.join(" ")} -out:#{out_file}") {|stdin, stdout, stderr, wait_thr|
+              pid = wait_thr.pid # pid of the started process.
+
+              @exit_status = wait_thr.value # Process::Status object returned.
+          
+              stderr.each do |x|
+                @exit_msg << x    
+              end
+            }   
+                         
+            references.each {|x| FileUtils.cp x, File.join(tmp_dir, "VikingIO") }         
+          
+            if @exit_status.success? == false
+              puts "ERROR COMPILING: #{@exit_msg}"
+              return false;
+            end                                                                               
+          end 
+          
+          node_data.each {|x| FileUtils.rm_rf File.join(tmp_dir, "VikingIO", "#{x}.cs") } 
+          
+          src_files = Dir.glob("#{tmp_dir}/VikingIO/**").reject {|x| x.end_with?("exe") || x.end_with?("Data") || x.end_with?("dll") }
+          src_files.each {|x| FileUtils.rm_rf x }
+               
+        rescue Exception => e  
+          puts "Error compiling: #{e}"
+          return false
+        end           
+      end
+      
+      def self.compile_and_run(*args)
+                                                   
+        tmp_dir = File.join(Dir.tmpdir, "vikingio")
+        node_data = VikingIO::CLI.get_node_data
+        default_port = 14242
+        
+        if self.compile_nodes(tmp_dir, node_data)
+          pids = []      
+            
+          node_data.each do |node|                     
+            default_port += 1
+            exe_file = "#{tmp_dir}/VikingIO/#{node["node_class"]}.exe"               
+            pids << spawn("DYLD_LIBRARY_PATH=#{UNITY_MONO_DLL_PATH_OSX} #{UNITY_MONO_PATH_OSX} #{exe_file} #{default_port}")
+          end 
+         
+          begin
+            puts "Press ctrl-C to stop"
+            while true do
+              sleep 0.1
+            end
+          rescue Interrupt => e  
+            pids.each {|pid| Process.kill("HUP",pid) }
+            puts "Stopped processes: #{pids.join(",")}."
+          end
+        else
+          
+        end 
+      end   
+      
+      def self.link(*args)
+      end
+         
+      def self.unlink(*args)
+        VikingIO::CLI.unlink_app
+        puts "Application data cleared."
+      end
+      
+      def self.create(*args)     
+        args.flatten!
+        
+        if !VikingIO::CLI.authenticated?
+          puts "Please login first."
+          return       
+        end    
+        
+        if VikingIO::CLI.linked?
+          puts "A VikingIO application is already linked to this directory. Use 'vikingio unlink' to clear the application data for this directory."
+          return
+        end
+        
+        app_name = args.shift.join(" ") rescue nil
+        
+        app = VikingIO::CLI::Client.create_app(app_name) 
+        
+        VikingIO::CLI.link_app(app)             
+        
+        puts "Created application '#{app['name']}'."     
+        
+        self.generate("--force")
+      end     
+      
+      def self.generate(*args)
+        args.flatten!
+        
+        assets_path = File.join(Dir.pwd, "Assets")
+        viking_assets_path = File.join(assets_path, "VikingIO")           
+        app_data = VikingIO::CLI.get_app_data          
+        
+        if args[0] == "node"                                       
+          if args[1] == "" || args[1] == nil
+            puts "Please enter a camel cased name for your node. i.e. GameServer"
+            return
+          end
+          
+          node_data = VikingIO::CLI::Client.create_node(args[1], app_data["key"]) 
+          VikingIO::CLI.save_node_data(node_data["nodes"])
+          
+          puts ""  
+          
+          
+          if node_data["status"] == "error"       
+            puts node_data["msg"]
+            puts "\nIf you want to create a new node, delete your existing node with 'vikingio destroy node #{node_data["nodes"][0]["node_class"]}'. \nThis will shut down any deployed and running node instances.\n\n"
+          end 
+          
+          node_output_path = File.join(viking_assets_path, "Server", "#{args[1]}.cs")
+          if File.exist?(node_output_path)
+            puts "#{node_output_path} already exists. Ignoring template generation. Delete the file first if you want to override it."
+          else
+            server_node_template = File.read(File.join(TEMPLATES_DIR, "ServerNodeTemplate.cs")).gsub("[SERVER_NAME]", args[1])
+            File.open(node_output_path, 'w') { |file| file.write(server_node_template) }
+          end
+          
+          return                                                                     
+          
+          node_output_path = File.join(viking_assets_path, "Server", "#{args[1]}.cs")
+          
+          if !File.exist?(node_output_path)
+            server_node_template = File.read(File.join(TEMPLATES_DIR, "ServerNodeTemplate.cs")).gsub("[SERVER_NAME]", args[1])
+            File.open(node_output_path, 'w') { |file| file.write(server_node_template) } 
+            node_data = VikingIO::CLI.get_node_data
+            node_data << args[1]
+            VikingIO::CLI.save_node_data(node_data) 
+          end                      
+          
+          puts "Node '#{args[1]}' created."
+          return
+        end      
+        
+        if args[0] == "message"
+          puts "Message '#{args[1]}' created."
+          server_node_template = File.read(File.join(TEMPLATES_DIR, "MessageTemplate.cs")).gsub("[MESSAGE_NAME]", args[1])
+          File.open(File.join(viking_assets_path, "Shared", "Messages", "#{args[1]}.cs"), 'w') { |file| file.write(server_node_template) }
+          return
+        end
+        
+        if File.exist?(viking_assets_path) && !args.include?("--force")
+          puts "VikingIO already exists in your Assets folder. Run this command again with the --force command to overwrite."
+          return
+        end                   
+        
+        puts "Generating skeleton application"                  
+        
+#        puts "Generating folder structure..."
+        FileUtils::mkdir_p(File.join(viking_assets_path, "Client", "External"))
+        FileUtils::mkdir_p(File.join(viking_assets_path, "Server", "External"))
+        FileUtils::mkdir_p(File.join(viking_assets_path, "Shared", "Messages"))
+        FileUtils::mkdir_p(File.join(viking_assets_path, "Data"))     
+             
+        dlls_dir = File.join(File.dirname(__FILE__), "../../../dlls")   
+        
+        config_dest = File.join(viking_assets_path, "Client", "VikingIO.Config.cs")
+        
+#        puts "Copying template files..."                                                                                     
+        FileUtils.cp(File.join(TEMPLATES_DIR, "NetworkManager.cs"), File.join(viking_assets_path, "Client", "NetworkManager.cs")) 
+        FileUtils.cp(File.join(TEMPLATES_DIR, "VikingIO.Config.cs"), config_dest)                                                 
+                                                     
+        contents = File.read(config_dest).gsub("[APP_NAME]", app_data["name"]).gsub("[APP_ID]", app_data["id"].to_s)
+             
+        File.open(config_dest, 'w') { |file| file.write(contents) }
+        
+        File.open(File.join(viking_assets_path, "Nodefile"), "w") do |f|
+          f << [].to_json
+        end           
+        
+#        puts "Copying dlls..."
+        FileUtils.cp(File.join(dlls_dir, "VikingIO.Network.dll"), File.join(viking_assets_path, "Server", "External", "VikingIO.Network.dll")) 
+        FileUtils.cp(File.join(dlls_dir, "VikingIO.Network.Client.dll"), File.join(viking_assets_path, "Client", "External", "VikingIO.Network.Client.dll"))
+#        puts "Done."
+      end
+      
+      def self.help(*args) 
+        args.flatten!
+        if args.size == 0
+          puts "\nCommands: \n\n"     
+          
+          COMMANDS.each do |cmd|   
+            if cmd[1][:short].nil?   
+              puts cmd[0]
+            else
+              puts "#{cmd[0]} - #{cmd[1][:short]}"
+            end
+          end
+
+          puts ""     
+        else
+          cmd = COMMANDS.find {|x| x[0] == args[0] }
+
+          puts "\n===========  " + cmd[0] + "  ===========\n\n"
+          puts cmd[1][:short] + "\n\n"                      
+          puts cmd[1][:full]
+        end   
+        puts ""              
+      end 
+      
+      def self.login(*args)   
+        email = ""
+        password = ""
+        
+        puts "Enter your email:"
+        email = STDIN.gets.chomp
+        
+        puts ""
+        puts "Enter your password:"
+        password = STDIN.noecho(&:gets).chomp
+                                                  
+        if email.nil? || email == "" || password.nil? || password == ""
+          puts "Email or Password empty" 
+          return 
+        end           
+        
+        app_key = VikingIO::CLI::Client.authenticate(email, password)    
+        
+        if app_key.nil?
+          puts "Invalid authentication." 
+          return         
+        end
+        
+        if VikingIO::CLI.netrc_exist?
+          if VikingIO::CLI.in_netrc?
+            VikingIO::CLI.update_netrc_key(app_key)
+          else
+            VikingIO::CLI.add_netrc_key(email, app_key)
+          end                       
+          puts "Authenticated #{email}."
+        else
+          
+        end                       
+        
+      end
+
+      def self.logout(*args)           
+        VikingIO::CLI.remove_netrc_key 
+        
+        puts "Authentication cleared."
+      end
+      
+    end
+  end
+end
+                                                                                                              
+
+
+

data/lib/vikingio/cli/helpers.rb

@@ -0,0 +1,110 @@
+module VikingIO
+  module CLI   
+    NETRC_PATH = File.join(Dir.home, ".netrc")
+    NETRC_ENTRY_RX = /machine\s+vikingio.com\s+login\s+(.*)\s+password\s+(.*)[\s+]?/i   
+    APP_DATA_FILENAME = ".vikingio"
+    NODE_DATA_FILENAME = "Nodefile"     
+    
+    def self.node_data_path
+      File.join(Dir.pwd, "Assets", "VikingIO", NODE_DATA_FILENAME)
+    end  
+                         
+    def self.get_node_data
+      return unless File.exist?(self.node_data_path)
+      d = File.read(self.node_data_path) 
+      return JSON.parse(d)
+    end      
+    
+    def self.save_node_data(data)
+       File.open(self.node_data_path, 'w') do |f|
+        f << data.to_json
+      end
+    end
+    
+    def self.get_app_data   
+      return unless File.exist?(self.app_data_path)
+      d = File.read(self.app_data_path) 
+      return JSON.parse(d)
+    end
+    
+    def self.link_app(app)
+      File.open(self.app_data_path, 'w') do |f|
+        f << app.to_json
+      end
+    end         
+    
+    def self.unlink_app  
+      return unless File.exist?(self.app_data_path)
+      FileUtils.rm_rf(app_data_path)
+    end
+    
+    def self.linked?
+      File.exist?(self.app_data_path)
+    end
+    
+    def self.authenticated?
+      return true if VikingIO::CLI.netrc_exist? && VikingIO::CLI.in_netrc?
+      return false
+    end
+    
+    def self.app_data_path
+      File.join(Dir.pwd, APP_DATA_FILENAME)
+    end
+    
+    def self.netrc_contents
+      File.read(NETRC_PATH)
+    end
+                 
+    def self.netrc_exist?()
+      File.exist?(NETRC_PATH)
+    end                     
+    
+    def self.in_netrc?()
+      netrc_contents =~ /machine\s+vikingio.com/i
+    end         
+    
+    def self.get_netrc_key
+      data = NETRC_ENTRY_RX.match(netrc_contents)
+      
+      email = data[1]
+      key = data[2]   
+      
+      return key
+    end
+    
+    def self.update_netrc_key(new_password)
+      netrc = netrc_contents
+      
+      data = NETRC_ENTRY_RX.match(netrc)
+      
+      existing_email = data[1]
+      existing_password = data[2]
+      
+      netrc.gsub!(existing_password, new_password)     
+      
+      save_netrc(netrc)
+    end     
+    
+    def self.add_netrc_key(email, key)
+      netrc = netrc_contents
+                       
+      netrc += "machine vikingio.com\n  login " + email + "\n  password " + key + "\n"
+      
+      save_netrc(netrc)
+    end
+
+    def self.remove_netrc_key
+      netrc = netrc_contents
+                       
+      netrc.gsub!(NETRC_ENTRY_RX, "")
+      
+      save_netrc(netrc)
+    end
+    
+    def self.save_netrc(netrc_contents)
+      File.open(NETRC_PATH, 'w') { |file| file.write(netrc_contents) }
+    end                          
+    
+  end  
+
+end

data/lib/vikingio/cli/version.rb

@@ -0,0 +1,5 @@
+module VikingIO
+  module CLI
+    VERSION = "0.0.2"
+  end
+end

data/lib/vikingio/cli.rb

@@ -0,0 +1,44 @@
+require 'net/http'        
+require 'uri'            
+require 'io/console'   
+require 'json'     
+require 'fileutils'     
+require 'yaml'
+require 'tmpdir'     
+require 'open3'      
+require 'net/http/post/multipart'    
+
+lib = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)                              
+
+require "vikingio/cli/version"    
+require "vikingio/cli/helpers"      
+require "vikingio/cli/client"
+require "vikingio/cli/commands"     
+
+module VikingIO
+  module CLI
+    
+    def self.start(*args)
+      begin
+        if $stdin.isatty
+          $stdin.sync = true
+        end
+        if $stdout.isatty
+          $stdout.sync = true
+        end
+
+        command = args.shift.strip rescue "help" 
+        args.flatten!
+
+        VikingIO::CLI::Commands.run(command, args)
+
+      rescue Interrupt
+        puts "Command cancelled."
+      rescue => error    
+        puts error
+      end
+    end 
+    
+  end
+end

data/templates/MessageTemplate.cs

@@ -0,0 +1,25 @@
+using System.Collections;
+
+using VikingIO.Network;
+using VikingIO.Network.Messaging;
+
+public class [MESSAGE_NAME] : BaseNetworkMessage
+{
+
+    public [MESSAGE_NAME]()
+    {
+
+    }
+
+    public override void Deserialize(INetIncomingMessage serializedMessage)
+    {
+        GetMessageInformation(serializedMessage);
+		// Deserialize your message data here
+    }
+
+    public override void Serialize(INetOutgoingMessage message)
+    {
+		// Serialize your message data here
+    }
+
+}

data/templates/NetworkManager.cs

@@ -0,0 +1,34 @@
+using UnityEngine;
+using System;
+using System.Collections;
+
+using VikingIO.Network;
+using VikingIO.Network.Messaging;
+
+public class NetworkManager : VikingSingleton<NetworkManager>
+{
+    protected NetworkManager()
+    {
+    }
+
+    private VikingClient m_NetClient;
+
+    public VikingClient Client
+    {
+        get { return m_NetClient; }
+    }
+
+    void Awake()
+    {
+        m_NetClient = new VikingClient(VikingIOConfig.APP_NAME, VikingIOConfig.APP_ID);  
+
+        Instance.Client.Start(true);                                                                                       
+
+        Debug.LogWarning("VikingIO NetworkManager started");
+    }        
+
+    void Update()
+    {
+        Instance.Client.Update();
+    }
+}

data/templates/Program.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using VikingIO.Network;
+
+namespace VikingIO.ServerNode
+{
+    class Program
+    {
+				static void Main(string[] args)
+				{                                      
+						if (args.Length == 0)
+						{        
+						  Console.WriteLine("Supply port as first argument.");
+							return;
+						}
+						VikingServer.Instance.SetNode(new [MODULE_NAME]());
+					  VikingServer.Instance.Start("[APP_NAME]", int.Parse(args[0]));    
+				}
+		}
+}

data/templates/ServerNodeTemplate.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using VikingIO.Network;
+using VikingIO.Network.Messaging;
+
+public class [SERVER_NAME] : IVikingNode
+{
+	int tick = 0;
+	VikingServer server;                      
+	
+	public void Start(VikingServer server)
+	{
+		Console.WriteLine("[[SERVER_NAME]] Start");
+		this.server = server;                                                                                        
+	}     
+	
+	public void OnConnect(NetConnection conn)
+	{            
+		Console.WriteLine(conn.RemoteEndPoint.ToString () + " connected.");
+	}
+	
+	public void OnDisconnect(NetConnection conn)
+	{  
+		Console.WriteLine(conn.RemoteEndPoint.ToString () + " disconnected.");                           
+	}
+	
+	public void Stop()
+	{
+		Console.WriteLine("[[SERVER_NAME]] Stop");
+	}
+	
+	public void Update(float dt)
+	{  
+		
+	}
+	
+	public void FixedUpdate(float dt)
+	{
+		
+	}  
+}

data/templates/VikingIO.Config.cs

@@ -0,0 +1,9 @@
+using UnityEngine;
+using System.Collections;
+
+public class VikingIOConfig {
+
+	public const string APP_NAME = "[APP_NAME]"; 
+	public const int APP_ID = [APP_ID];
+
+}

data/vikingio-cli.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vikingio/cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vikingio"
+  spec.version       = VikingIO::CLI::VERSION
+  spec.authors       = ["Eric Campbell"]
+  spec.email         = ["info@vikingio.com"]
+  spec.summary       = %q{VikingIO command line toolkit.}
+  spec.description   = %q{VikingIO command line toolkit.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["vikingio"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: vikingio
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Eric Campbell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: VikingIO command line toolkit.
+email:
+- info@vikingio.com
+executables:
+- vikingio
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/vikingio
+- dlls/.DS_Store
+- dlls/VikingIO.Network.Client.dll
+- dlls/VikingIO.Network.dll
+- lib/vikingio/cli.rb
+- lib/vikingio/cli/client.rb
+- lib/vikingio/cli/commands.rb
+- lib/vikingio/cli/helpers.rb
+- lib/vikingio/cli/version.rb
+- templates/MessageTemplate.cs
+- templates/NetworkManager.cs
+- templates/Program.cs
+- templates/ServerNodeTemplate.cs
+- templates/VikingIO.Config.cs
+- vikingio-cli.gemspec
+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.2.2
+signing_key: 
+specification_version: 4
+summary: VikingIO command line toolkit.
+test_files: []