telestream_cloud 1.0.0

data/lib/telestream_cloud/proxies/video_scope.rb

@@ -0,0 +1,28 @@
+module TelestreamCloud
+  class VideoScope < Scope
+
+    def initialize(parent)
+      super(parent, Video)
+    end
+
+    def non_delegate_methods
+      super + [:status, :page, :per_page]
+    end
+
+    def page(this_page)
+      @scoped_attributes[:page] = this_page
+      self
+    end
+
+    def per_page(this_per_page)
+      @scoped_attributes[:per_page] = this_per_page
+      self
+    end
+
+    def status(this_status)
+      @scoped_attributes[:status] = this_status
+      self
+    end
+
+  end
+end

data/lib/telestream_cloud/resources/encoding.rb

@@ -0,0 +1,47 @@
+module TelestreamCloud
+  class Encoding < Resource
+    include VideoState
+
+    belongs_to :video
+    has_one :profile
+
+    class << self
+      def first
+        EncodingScope.new(self).per_page(1).first
+      end
+    end
+
+    def url(options={})
+      default_options = {:https => false}
+      options = default_options.merge(options)
+      full_path = "#{path}#{extname}"
+      get_url(full_path, options[:https]) if files.include?(full_path)
+    end
+    
+    def urls(options={})
+      default_options = {:https => false}
+      options = default_options.merge(options)
+      files.map {|f| get_url(f, options[:https])}
+    end
+
+    def screenshots(options={})
+      default_options = {:https => false}
+      options = default_options.merge(options)
+      ((1..7).map{|i| get_url("#{path}_#{i}.jpg", options[:https])} if success?) || []
+    end
+
+    def cancel
+      connection.post("/encodings/#{id}/cancel.json")['canceled']
+    end
+
+    def retry
+      connection.post("/encodings/#{id}/retry.json")['retried']
+    end
+
+    private
+
+    def get_url(end_path, https)
+      "#{https ? factory.https_url : factory.url}#{end_path}"
+    end
+  end
+end

data/lib/telestream_cloud/resources/factory.rb

@@ -0,0 +1,72 @@
+module TelestreamCloud
+  class Factory < Base
+    include TelestreamCloud::Updatable
+    
+    attr_reader :connection
+
+    def initialize(attributes={})
+      super(attributes)
+      connection_params = TelestreamCloud.connection.to_hash.merge!(:factory_id => id)
+      @connection = Connection.new(connection_params)
+      TelestreamCloud.factories[id] = self
+    end
+
+    class << self
+
+      def connection
+        TelestreamCloud.connection
+      end
+      
+      private
+
+      def build_resource(attributes)
+        resource = TelestreamCloud::Factory.new(attributes)
+      end
+    end
+
+    def https_url
+      uri = URI.parse(url)
+      uri.scheme = "https"
+      uri.to_s
+    end
+
+    def eu?
+      region == "eu"
+    end
+
+    def us?
+      region == "us"
+    end
+
+    def region
+      return 'eu' if connection.api_host == TelestreamCloud::EU_API_HOST
+      return 'us' if connection.api_host == TelestreamCloud::US_API_HOST
+      return 'gce' if connection.api_host == TelestreamCloud::GCE_API_HOST
+    end
+
+    def videos
+      VideoScope.new(self)
+    end
+
+    def encodings
+      EncodingScope.new(self)
+    end
+
+    def profiles
+      ProfileScope.new(self)
+    end
+
+    def method_missing(method_symbol, *arguments)
+      lazy_load
+      super
+    end
+
+    private 
+    
+    def lazy_load
+      reload unless @loaded
+    end
+
+  end
+end
+

data/lib/telestream_cloud/resources/profile.rb

@@ -0,0 +1,22 @@
+module TelestreamCloud
+  class Profile < Resource
+    include TelestreamCloud::Updatable
+
+    has_many :encodings
+
+    def preset?
+      !preset_name
+    end
+
+    # override attributes command and preset_name
+    # to ovoid <method undefined> when profile is a preset or not
+    def command
+      @attributes['command']
+    end
+
+    def preset_name
+      @attributes['preset_name']
+    end
+
+  end
+end

data/lib/telestream_cloud/resources/resource.rb

@@ -0,0 +1,48 @@
+module TelestreamCloud
+  class Resource < Base
+    include TelestreamCloud::Destroyers
+    include TelestreamCloud::Associations
+    include TelestreamCloud::FactoryConnection
+
+    def initialize(attributes={})
+      super(attributes)
+      @attributes['factory_id'] ||= TelestreamCloud.factory.id
+    end
+
+    class << self
+      include TelestreamCloud::FactoryConnection
+
+      def factory
+        TelestreamCloud.factory
+      end
+
+      # delegate to the scope if the method exists
+      def method_missing(method_symbol, *args, &block)
+        scope = TelestreamCloud::const_get("#{sti_name}Scope").new(self)
+        if scope.respond_to?(method_symbol)
+           scope.send(method_symbol, *args, &block)
+        else
+          super
+        end
+      end
+
+    end
+
+    def factory
+      TelestreamCloud.factories[factory_id]
+    end
+
+    def reload
+      perform_reload("factory_id" => factory_id)
+      reset_associations
+      self
+    end
+
+    private
+
+    def load_and_reset(response)
+      load_response(response.merge('factory_id' => factory.id))
+    end
+
+  end
+end

data/lib/telestream_cloud/resources/video.rb

@@ -0,0 +1,39 @@
+module TelestreamCloud
+  class Video < Resource
+    include VideoState
+    has_many :encodings
+
+    class << self
+      def first
+        VideoScope.new(self).per_page(1).first
+      end
+    end
+
+    def metadata
+      connection.get("/videos/#{id}/metadata.json")
+    end
+
+    def delete_source
+      connection.delete("/videos/#{id}/source.json")
+    end
+
+    def preview_url(options={})
+      default_options = {:https => false}
+      options = default_options.merge(options)
+      get_url("#{path}_1.jpg", options[:https]) if success?
+    end
+
+    def url(options={})
+      default_options = {:https => false}
+      options = default_options.merge(options)
+      get_url("#{path}#{extname}", options[:https]) if success?
+    end
+
+    private
+
+    def get_url(end_path, https)
+      "#{https ? factory.https_url : factory.url}#{end_path}"
+    end
+
+  end
+end

data/lib/telestream_cloud/telestream_cloud.rb

@@ -0,0 +1,69 @@
+module TelestreamCloud
+
+  extend self
+  extend Forwardable
+
+  attr_reader :factory, :factories
+  attr_reader :connection
+
+  def_delegators :connection, :get, :post, :put, :delete, :api_url, :setup_bucket, :signed_params
+
+  RESOURCES = {
+    flip: TelestreamCloud::Flip
+  }
+
+  def configure(auth_params=nil, &block)
+    raise ArgumentError, "missing auth params or block" unless auth_params || block_given?
+
+    if !auth_params
+      config = Config.new
+      if (block.arity > 0)
+        block.call(config)
+      else
+        config.instance_eval(&block)
+      end
+    elsif auth_params.is_a?(String)
+      config = Config.from_panda_url(auth_params)
+    else
+      config = Config.from_hash(auth_params)
+    end
+
+    configure_with_auth_params(config)
+    true
+  end
+
+  def configure_heroku
+    configure_with_auth_params Config.from_panda_url(ENV['PANDASTREAM_URL'])
+    true
+  end
+
+  def connect!(auth_params)
+    @connection = Connection.new(auth_params)
+  end
+
+  def connection
+    raise TelestreamCloud::ConfigurationError, "Telestream Cloud is not configured!" unless @connection
+    @connection
+  end
+
+  def default_adapter=(adapter_name)
+    @adapter = adapter_name.to_sym
+  end
+
+  def default_adapter
+    @adapter
+  end
+
+  def resources(resource_name)
+    RESOURCES[resource_name].new
+  end
+  
+  private
+
+  def configure_with_auth_params(config)
+    config.validate!
+    connect!(config.to_hash)
+    @factories = {}
+    @factory = Factory::new(:id => @connection.factory_id)
+  end
+end

data/lib/telestream_cloud/upload_session.rb

@@ -0,0 +1,102 @@
+CHUNK_SIZE = 100 * 1024 # 5 * 1024 * 1024
+
+class File
+  def each_chunk_with_index()
+    i = 0
+    until eof?
+      yield(read(CHUNK_SIZE), i)
+      i = i+1
+    end
+  end
+end
+
+module TelestreamCloud
+  class UploadSession
+    attr_reader :location, :status, :video, :error_message, :file_name, :file_size
+
+    def initialize(file_name, options={})
+      @file_name = file_name
+      @file_size = File.size(file_name)
+      params = { 
+        :file_size => @file_size,
+        :file_name => @file_name,
+      }.merge(options)
+
+      data = TelestreamCloud.post("/videos/upload.json", params)
+      @location = URI.parse(data["location"])  
+      @status = "initialized"
+      @video = nil
+      @error_message = nil
+    end
+
+    def start(pos=0)
+      if @status == "initialized"
+        @status = "uploading"
+        open(@file_name, "rb") do |f|
+          f.seek(pos)
+          f.each_chunk_with_index() { |chunk, i|
+            begin
+              index = i * CHUNK_SIZE
+                uri = URI.parse(URI.encode(@location.to_s))
+                https = Net::HTTP.new(uri.host, uri.port)
+                https.use_ssl = true
+            
+                request = Net::HTTP::Post.new(uri.request_uri, initheader = {
+                  'Content-Type' =>'application/octet-stream',
+                  'Cache-Control' => 'no-cache',
+                  'Content-Range' => "bytes #{pos+index}-#{pos+index+CHUNK_SIZE-1}/#{@file_size}",
+                  'Content-Length' => "#{CHUNK_SIZE}"
+                })
+                request.body = chunk
+  
+                response = https.request(request)
+                if response.code == '200'
+                  @status = "uploaded"
+                  @video = TelestreamCloud::Video.new(JSON.parse(response.body))
+                elsif response.code != '204'
+                  @statys = "error"
+                  break  
+                end 
+            rescue Exception => e
+              @status = "error"
+              @error_mesage = e.message
+              raise e
+            end 
+          }
+        end
+      else
+        raise "Already started"
+      end
+    end
+
+    def resume()
+      if @status != "uploaded"
+        uri = URI.parse(URI.encode(@location.to_s))
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+    
+        request = Net::HTTP::Post.new(uri.request_uri, initheader = {
+          'Content-Type' =>'application/octet-stream',
+          'Cache-Control' => 'no-cache',
+          'Content-Range' => "bytes */#{@file_size}",
+          'Content-Length' => "0"
+        })
+        response = https.request(request)
+        pos = response["Range"].split("-")[1]
+        @status = "initialized"
+        self.start(pos.to_i)
+      else
+        raise ("Already succeed")
+      end
+    end
+
+    def abort()
+      if @status != "success"
+        @status = "aborted"
+        @error_message = nil
+      else
+        raise "Already succeed"
+      end
+    end
+  end
+end

data/lib/telestream_cloud/version.rb

@@ -0,0 +1,3 @@
+module TelestreamCloud
+  VERSION = "1.0.0"
+end

data/spec/cloud_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe TelestreamCloud::Factory do
+
+  describe "region" do
+    it "should tell the region" do
+      TelestreamCloud.configure do
+        access_key "my_access_key"
+        secret_key "my_secret_key"
+        api_host "api.pandastream.com"
+        factory_id 'my_cloud_id'
+        api_port 85
+      end
+
+      TelestreamCloud.factory.region.should == "us"
+      TelestreamCloud.factory.us?.should == true
+    end
+
+    it "should tell the region" do
+      TelestreamCloud.configure do
+        access_key "my_access_key"
+        secret_key "my_secret_key"
+        api_host "api-eu.pandastream.com"
+        factory_id 'my_cloud_id'
+        api_port 85
+      end
+
+      TelestreamCloud.factory.region.should == "eu"
+      TelestreamCloud.factory.eu?.should == true
+    end
+
+  end
+
+
+
+
+  describe "Using configure bloc" do
+    before(:each) do
+      TelestreamCloud.configure do
+        access_key "my_access_key"
+        secret_key "my_secret_key"
+        api_host "api.example.com"
+        factory_id 'my_cloud_id'
+        api_port 85
+      end
+    end
+
+    describe "using a cloud" do
+      before(:each) do
+         cloud_json = "{\"s3_videos_bucket\":\"my_bucket1\",\"id\":\"cloud1\"}"
+          stub_http_request(:get, /api.example.com:85\/v3.0\/factories\/cloud1.json/).
+            to_return(:body => cloud_json)
+          @factory = TelestreamCloud::Factory.find "cloud1"
+      end
+
+      it "should find all videos" do
+        videos_json = "[{\"source_url\":\"my_source_url\",\"id\":\"123\"}]"
+        stub_http_request(:get, /api.example.com:85\/v3.0\/videos.json/).
+            with{|r| r.uri.query =~ /factory_id=cloud1/}.
+              to_return(:body => videos_json)
+
+        @factory.videos.first.id.should == "123"
+      end
+
+      it "should find all videos with params" do
+        videos_json = "[{\"source_url\":\"my_source_url\",\"id\":\"134\"}]"
+        stub_http_request(:get, /api.example.com:85\/v3.0\/videos.json/).
+          with{|r| r.uri.query =~ /status=success/ && r.uri.query =~ /factory_id=cloud1/}.
+            to_return(:body => videos_json)
+        videos = @factory.videos.all(:status => "success")
+        videos.first.id.should == "134"
+      end
+
+      it "should find a video by id" do
+        video_json = "{\"source_url\":\"my_source_url\",\"id\":\"123\"}"
+        stub_http_request(:get, /api.example.com:85\/v3.0\/videos\/123.json/).
+          with{|r| r.uri.query =~ /factory_id=cloud1/}.
+          to_return(:body => video_json)
+
+        video = @factory.videos.find "123"
+        video.id.should == "123"
+      end
+
+      it "should create a video using cloud" do
+        videos_json = "{\"source_url\":\"my_source_url\",\"id\":\"123\"}"
+        stub_http_request(:post, /api.example.com:85\/v3.0\/videos.json/).
+          with{|r| r.body =~ /factory_id=cloud1/}.
+          to_return(:body => videos_json)
+        @factory.videos.create(:source_url => "my_source_url")
+      end
+
+      it "should find return all cloud" do
+        clouds_json = "[{\"s3_videos_bucket\":\"my_bucket1\",\"id\":\"cloud1\"},{\"s3_videos_bucket\":\"my_bucket2\",\"id\":\"cloud2\"}]"
+
+        stub_http_request(:get, /api.example.com:85\/v3.0\/factories.json/).to_return(:body => clouds_json)
+
+        factory = TelestreamCloud::Factory.all
+        factory.first.id.should == 'cloud1'
+        factory.first.s3_videos_bucket.should == "my_bucket1"
+        factory.size.should == 2
+      end
+    end
+
+
+    it "should create a cloud" do
+      cloud_json = "{\"s3_videos_bucket\":\"videobucket\",\"id\":\"my_cloud_id\"}"
+      stub_http_request(:post, /http:\/\/api.example.com:85\/v3.0\/factories.json/).
+        with{|r| r.body =~ /s3_videos_bucket=videobucket/ &&  r.body =~ /user_aws_key=myaccesskey/ &&  r.body =~ /user_aws_secret=mysecretkey/ }.
+        to_return(:body => cloud_json)
+
+      @cloud = TelestreamCloud::Factory.create(:s3_videos_bucket => 'videobucket', :user_aws_key => 'myaccesskey', :user_aws_secret => 'mysecretkey')
+      @cloud.s3_videos_bucket.should == "videobucket"
+    end
+
+
+    it "should create a cloud and reload" do
+      cloud_json = "{\"s3_videos_bucket\":\"videobucket\",\"id\":\"my_new_cloud_id\"}"
+      stub_http_request(:post, /http:\/\/api.example.com:85\/v3.0\/factories.json/).
+        to_return(:body => cloud_json)
+
+      stub_http_request(:get, /api.example.com:85\/v3.0\/factories\/my_new_cloud_id.json/).
+        to_return(:body => cloud_json)
+
+      @cloud = TelestreamCloud::Factory.create(:s3_videos_bucket => 'videobucket', :user_aws_key => 'myaccesskey', :user_aws_secret => 'mysecretkey')
+      @cloud.reload.should == @cloud
+    end
+
+  end
+
+
+
+end