Class: Kaltura::KalturaLiveStreamService

Inherits:
KalturaServiceBase show all
Defined in:
lib/kaltura_client.rb

Overview

Live Stream service lets you manage live stream entries

Instance Attribute Summary

Attributes inherited from KalturaServiceBase

#client

Instance Method Summary collapse

Constructor Details

#initialize(client) ⇒ KalturaLiveStreamService

Returns a new instance of KalturaLiveStreamService.



2504
2505
2506
 
# File 'lib/kaltura_client.rb', line 2504

def initialize(client)
	super(client)
end

Instance Method Details

#add(live_stream_entry, source_type = KalturaNotImplemented) ⇒ KalturaLiveStreamEntry

Adds new live stream entry. The entry will be queued for provision.

Returns:



2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
 
# File 'lib/kaltura_client.rb', line 2511

def add(live_stream_entry, source_type=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'liveStreamEntry', live_stream_entry)
	client.add_param(kparams, 'sourceType', source_type)
	client.queue_service_action_call('livestream', 'add', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#add_live_stream_push_publish_configuration(entry_id, protocol, url = KalturaNotImplemented, live_stream_configuration = KalturaNotImplemented) ⇒ KalturaLiveStreamEntry

Add new pushPublish configuration to entry

Returns:



2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
 
# File 'lib/kaltura_client.rb', line 2524

def add_live_stream_push_publish_configuration(entry_id, protocol, url=KalturaNotImplemented, live_stream_configuration=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'protocol', protocol)
	client.add_param(kparams, 'url', url)
	client.add_param(kparams, 'liveStreamConfiguration', live_stream_configuration)
	client.queue_service_action_call('livestream', 'addLiveStreamPushPublishConfiguration', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#allocate_conference_room(entry_id, env = '') ⇒ KalturaRoomDetails

Allocates a conference room or returns ones that has already been allocated

Returns:



2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
 
# File 'lib/kaltura_client.rb', line 2539

def allocate_conference_room(entry_id, env='')
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'env', env)
	client.queue_service_action_call('livestream', 'allocateConferenceRoom', 'KalturaRoomDetails', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#append_recording(entry_id, asset_id, media_server_index, resource, duration, is_last_chunk = false) ⇒ KalturaLiveEntry

Append recorded video to live entry

Returns:



2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
 
# File 'lib/kaltura_client.rb', line 2552

def append_recording(entry_id, asset_id, media_server_index, resource, duration, is_last_chunk=false)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'assetId', asset_id)
	client.add_param(kparams, 'mediaServerIndex', media_server_index)
	client.add_param(kparams, 'resource', resource)
	client.add_param(kparams, 'duration', duration)
	client.add_param(kparams, 'isLastChunk', is_last_chunk)
	client.queue_service_action_call('livestream', 'appendRecording', 'KalturaLiveEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#archive(live_entry_id, vod_entry_id) ⇒ bool

Archive a live entry which was recorded

Returns:

  • (bool) 


2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
 
# File 'lib/kaltura_client.rb', line 2569

def archive(live_entry_id, vod_entry_id)
	kparams = {}
	client.add_param(kparams, 'liveEntryId', live_entry_id)
	client.add_param(kparams, 'vodEntryId', vod_entry_id)
	client.queue_service_action_call('livestream', 'archive', 'bool', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#authenticate(entry_id, token, hostname = KalturaNotImplemented, media_server_index = KalturaNotImplemented, application_name = KalturaNotImplemented) ⇒ KalturaLiveStreamEntry

Authenticate live-stream entry against stream token and partner limitations

Returns:



2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
 
# File 'lib/kaltura_client.rb', line 2582

def authenticate(entry_id, token, hostname=KalturaNotImplemented, media_server_index=KalturaNotImplemented, application_name=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'token', token)
	client.add_param(kparams, 'hostname', hostname)
	client.add_param(kparams, 'mediaServerIndex', media_server_index)
	client.add_param(kparams, 'applicationName', application_name)
	client.queue_service_action_call('livestream', 'authenticate', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#create_periodic_sync_points(entry_id, interval, duration) ⇒ Object

Creates periodic metadata sync-point events on a live stream

Returns:



2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
 
# File 'lib/kaltura_client.rb', line 2598

def create_periodic_sync_points(entry_id, interval, duration)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'interval', interval)
	client.add_param(kparams, 'duration', duration)
	client.queue_service_action_call('livestream', 'createPeriodicSyncPoints', '', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#create_recorded_entry(entry_id, media_server_index, live_entry_status) ⇒ KalturaLiveEntry

Create recorded entry id if it doesn’t exist and make sure it happens on the DC that the live entry was created on.

Returns:



2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
 
# File 'lib/kaltura_client.rb', line 2612

def create_recorded_entry(entry_id, media_server_index, live_entry_status)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'mediaServerIndex', media_server_index)
	client.add_param(kparams, 'liveEntryStatus', live_entry_status)
	client.queue_service_action_call('livestream', 'createRecordedEntry', 'KalturaLiveEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#delete(entry_id) ⇒ Object

Delete a live stream entry.

Returns:



2626
2627
2628
2629
2630
2631
2632
2633
2634
 
# File 'lib/kaltura_client.rb', line 2626

def delete(entry_id)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.queue_service_action_call('livestream', 'delete', '', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#finish_conf(entry_id, server_node_id = KalturaNotImplemented) ⇒ bool

When the conf is finished this API should be called.

Returns:

  • (bool) 


2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
 
# File 'lib/kaltura_client.rb', line 2638

def finish_conf(entry_id, server_node_id=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'serverNodeId', server_node_id)
	client.queue_service_action_call('livestream', 'finishConf', 'bool', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#get(entry_id, version = -1)) ⇒ KalturaLiveStreamEntry

Get live stream entry by ID.

Returns:



2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
 
# File 'lib/kaltura_client.rb', line 2651

def get(entry_id, version=-1)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'version', version)
	client.queue_service_action_call('livestream', 'get', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#get_details(id) ⇒ KalturaLiveStreamDetails

Delivering the status of a live stream (on-air/offline) if it is possible

Returns:



2664
2665
2666
2667
2668
2669
2670
2671
2672
 
# File 'lib/kaltura_client.rb', line 2664

def get_details(id)
	kparams = {}
	client.add_param(kparams, 'id', id)
	client.queue_service_action_call('livestream', 'getDetails', 'KalturaLiveStreamDetails', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#is_live(id, protocol = KalturaNotImplemented) ⇒ bool

Delivering the status of a live stream (on-air/offline) if it is possible

Returns:

  • (bool) 


2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
 
# File 'lib/kaltura_client.rb', line 2676

def is_live(id, protocol=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'id', id)
	client.add_param(kparams, 'protocol', protocol)
	client.queue_service_action_call('livestream', 'isLive', 'bool', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#list(filter = KalturaNotImplemented, pager = KalturaNotImplemented) ⇒ KalturaLiveStreamListResponse

List live stream entries by filter with paging support.

Returns:



2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
 
# File 'lib/kaltura_client.rb', line 2689

def list(filter=KalturaNotImplemented, pager=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'filter', filter)
	client.add_param(kparams, 'pager', pager)
	client.queue_service_action_call('livestream', 'list', 'KalturaLiveStreamListResponse', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#regenerate_stream_token(entry_id) ⇒ KalturaLiveEntry

Regenerate new secure token for liveStream

Returns:



2702
2703
2704
2705
2706
2707
2708
2709
2710
 
# File 'lib/kaltura_client.rb', line 2702

def regenerate_stream_token(entry_id)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.queue_service_action_call('livestream', 'regenerateStreamToken', 'KalturaLiveEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#register_conf(entry_id) ⇒ bool

Mark that the conference has actually started

Returns:

  • (bool) 


2714
2715
2716
2717
2718
2719
2720
2721
2722
 
# File 'lib/kaltura_client.rb', line 2714

def register_conf(entry_id)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.queue_service_action_call('livestream', 'registerConf', 'bool', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#register_media_server(entry_id, hostname, media_server_index, application_name = KalturaNotImplemented, live_entry_status = 1, should_create_recorded_entry = true) ⇒ KalturaLiveEntry

Register media server to live entry

Returns:



2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
 
# File 'lib/kaltura_client.rb', line 2726

def register_media_server(entry_id, hostname, media_server_index, application_name=KalturaNotImplemented, live_entry_status=1, should_create_recorded_entry=true)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'hostname', hostname)
	client.add_param(kparams, 'mediaServerIndex', media_server_index)
	client.add_param(kparams, 'applicationName', application_name)
	client.add_param(kparams, 'liveEntryStatus', live_entry_status)
	client.add_param(kparams, 'shouldCreateRecordedEntry', should_create_recorded_entry)
	client.queue_service_action_call('livestream', 'registerMediaServer', 'KalturaLiveEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#remove_live_stream_push_publish_configuration(entry_id, protocol) ⇒ KalturaLiveStreamEntry

Remove push publish configuration from entry

Returns:



2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
 
# File 'lib/kaltura_client.rb', line 2743

def remove_live_stream_push_publish_configuration(entry_id, protocol)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'protocol', protocol)
	client.queue_service_action_call('livestream', 'removeLiveStreamPushPublishConfiguration', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#set_recorded_content(entry_id, media_server_index, resource, duration, recorded_entry_id = KalturaNotImplemented, flavor_params_id = KalturaNotImplemented) ⇒ KalturaLiveEntry

Set recorded video to live entry

Returns:



2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
 
# File 'lib/kaltura_client.rb', line 2756

def set_recorded_content(entry_id, media_server_index, resource, duration, recorded_entry_id=KalturaNotImplemented, flavor_params_id=KalturaNotImplemented)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'mediaServerIndex', media_server_index)
	client.add_param(kparams, 'resource', resource)
	client.add_param(kparams, 'duration', duration)
	client.add_param(kparams, 'recordedEntryId', recorded_entry_id)
	client.add_param(kparams, 'flavorParamsId', flavor_params_id)
	client.queue_service_action_call('livestream', 'setRecordedContent', 'KalturaLiveEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#unregister_media_server(entry_id, hostname, media_server_index) ⇒ KalturaLiveEntry

Unregister media server from live entry

Returns:



2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
 
# File 'lib/kaltura_client.rb', line 2773

def unregister_media_server(entry_id, hostname, media_server_index)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'hostname', hostname)
	client.add_param(kparams, 'mediaServerIndex', media_server_index)
	client.queue_service_action_call('livestream', 'unregisterMediaServer', 'KalturaLiveEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#update(entry_id, live_stream_entry) ⇒ KalturaLiveStreamEntry

Update live stream entry. Only the properties that were set will be updated.

Returns:



2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
 
# File 'lib/kaltura_client.rb', line 2787

def update(entry_id, live_stream_entry)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'liveStreamEntry', live_stream_entry)
	client.queue_service_action_call('livestream', 'update', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#update_offline_thumbnail_from_url(entry_id, url) ⇒ KalturaLiveStreamEntry

Update entry thumbnail using url

Returns:



2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
 
# File 'lib/kaltura_client.rb', line 2800

def update_offline_thumbnail_from_url(entry_id, url)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kparams, 'url', url)
	client.queue_service_action_call('livestream', 'updateOfflineThumbnailFromUrl', 'KalturaLiveStreamEntry', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#update_offline_thumbnail_jpeg(entry_id, file_data) ⇒ KalturaLiveStreamEntry

Update live stream entry thumbnail using a raw jpeg file

Returns:



2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
 
# File 'lib/kaltura_client.rb', line 2813

def update_offline_thumbnail_jpeg(entry_id, file_data)
	kparams = {}
	kfiles = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.add_param(kfiles, 'fileData', file_data)
	client.queue_service_action_call('livestream', 'updateOfflineThumbnailJpeg', 'KalturaLiveStreamEntry', kparams, kfiles)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end

#validate_registered_media_servers(entry_id) ⇒ Object

Validates all registered media servers

Returns:



2827
2828
2829
2830
2831
2832
2833
2834
2835
 
# File 'lib/kaltura_client.rb', line 2827

def validate_registered_media_servers(entry_id)
	kparams = {}
	client.add_param(kparams, 'entryId', entry_id)
	client.queue_service_action_call('livestream', 'validateRegisteredMediaServers', '', kparams)
	if (client.is_multirequest)
		return nil
	end
	return client.do_queue()
end