Initial working implementation of HLS proxy
This commit is contained in:
13
src/main/java/com/backend/hls/proxy/HlsProxyApplication.java
Normal file
13
src/main/java/com/backend/hls/proxy/HlsProxyApplication.java
Normal file
@ -0,0 +1,13 @@
|
||||
package com.backend.hls.proxy;
|
||||
|
||||
import org.springframework.boot.SpringApplication;
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||||
|
||||
@SpringBootApplication
|
||||
public class HlsProxyApplication {
|
||||
|
||||
public static void main(String[] args) {
|
||||
SpringApplication.run(HlsProxyApplication.class, args);
|
||||
}
|
||||
|
||||
}
|
||||
18
src/main/java/com/backend/hls/proxy/config/CacheConfig.java
Normal file
18
src/main/java/com/backend/hls/proxy/config/CacheConfig.java
Normal file
@ -0,0 +1,18 @@
|
||||
package com.backend.hls.proxy.config;
|
||||
|
||||
import org.springframework.cache.CacheManager;
|
||||
import org.springframework.cache.annotation.EnableCaching;
|
||||
import org.springframework.cache.caffeine.CaffeineCacheManager;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Configuration
|
||||
@EnableCaching
|
||||
public class CacheConfig {
|
||||
|
||||
@Bean
|
||||
public CacheManager cacheManager() {
|
||||
return new CaffeineCacheManager("hlsPlaylistContent", "playlistSegmentContent");
|
||||
}
|
||||
|
||||
}
|
||||
22
src/main/java/com/backend/hls/proxy/config/ParserConfig.java
Normal file
22
src/main/java/com/backend/hls/proxy/config/ParserConfig.java
Normal file
@ -0,0 +1,22 @@
|
||||
package com.backend.hls.proxy.config;
|
||||
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
import io.lindstrom.m3u8.parser.MediaPlaylistParser;
|
||||
import io.lindstrom.m3u8.parser.MultivariantPlaylistParser;
|
||||
import io.lindstrom.m3u8.parser.ParsingMode;
|
||||
|
||||
@Configuration
|
||||
public class ParserConfig {
|
||||
|
||||
@Bean
|
||||
public MultivariantPlaylistParser multivariantParser() {
|
||||
return new MultivariantPlaylistParser(ParsingMode.LENIENT);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public MediaPlaylistParser mediaParser() {
|
||||
return new MediaPlaylistParser(ParsingMode.LENIENT);
|
||||
}
|
||||
}
|
||||
24
src/main/java/com/backend/hls/proxy/config/RedisConfig.java
Normal file
24
src/main/java/com/backend/hls/proxy/config/RedisConfig.java
Normal file
@ -0,0 +1,24 @@
|
||||
package com.backend.hls.proxy.config;
|
||||
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
|
||||
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
|
||||
import org.springframework.data.redis.core.RedisTemplate;
|
||||
|
||||
@Configuration
|
||||
public class RedisConfig {
|
||||
@Bean
|
||||
public JedisConnectionFactory jedisConnectionFactory() {
|
||||
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("redis");
|
||||
return new JedisConnectionFactory(config);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public RedisTemplate<String, Object> redisTemplate() {
|
||||
RedisTemplate<String, Object> template = new RedisTemplate<>();
|
||||
template.setConnectionFactory(jedisConnectionFactory());
|
||||
return template;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,20 @@
|
||||
package com.backend.hls.proxy.config;
|
||||
|
||||
import java.net.http.HttpClient;
|
||||
import java.net.http.HttpClient.Redirect;
|
||||
import java.time.Duration;
|
||||
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
@Configuration
|
||||
public class RetrieverConfig {
|
||||
@Bean
|
||||
public HttpClient httpClient() {
|
||||
return HttpClient.newBuilder()
|
||||
.followRedirects(Redirect.NORMAL)
|
||||
.connectTimeout(Duration.ofSeconds(10))
|
||||
.build();
|
||||
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
package com.backend.hls.proxy.controller;
|
||||
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.GetMapping;
|
||||
import org.springframework.web.bind.annotation.RequestParam;
|
||||
import org.springframework.web.bind.annotation.RestController;
|
||||
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
|
||||
|
||||
import com.backend.hls.proxy.exception.FetchFailException;
|
||||
import com.backend.hls.proxy.exception.PlaylistParseException;
|
||||
import com.backend.hls.proxy.service.PlaylistProxyService;
|
||||
|
||||
@RestController
|
||||
public class ProxyController {
|
||||
|
||||
private final PlaylistProxyService playlistProxyService;
|
||||
|
||||
public ProxyController(PlaylistProxyService playlistProxyService) {
|
||||
this.playlistProxyService = playlistProxyService;
|
||||
}
|
||||
|
||||
@GetMapping("/proxy")
|
||||
public ResponseEntity<?> proxy(@RequestParam("url") String url) throws FetchFailException, PlaylistParseException {
|
||||
String fullUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().build().toUriString();
|
||||
String baseUrl = fullUrl.substring(0, fullUrl.indexOf("/", 8));
|
||||
String result = playlistProxyService.proxyPlaylist(url, baseUrl);
|
||||
return ResponseEntity.ok(result);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,118 @@
|
||||
package com.backend.hls.proxy.controller;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.URI;
|
||||
import java.util.Optional;
|
||||
|
||||
import org.springframework.http.HttpHeaders;
|
||||
import org.springframework.http.HttpStatus;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.GetMapping;
|
||||
import org.springframework.web.bind.annotation.PathVariable;
|
||||
import org.springframework.web.bind.annotation.RequestHeader;
|
||||
import org.springframework.web.bind.annotation.RestController;
|
||||
|
||||
import com.backend.hls.proxy.exception.FetchFailException;
|
||||
import com.backend.hls.proxy.exception.PlaylistParseException;
|
||||
import com.backend.hls.proxy.model.Link;
|
||||
import com.backend.hls.proxy.model.RangeRequest;
|
||||
import com.backend.hls.proxy.model.SimpleResponse;
|
||||
import com.backend.hls.proxy.repository.LinkRepository;
|
||||
import com.backend.hls.proxy.service.FetchService;
|
||||
|
||||
@RestController
|
||||
public class ProxyServeController {
|
||||
private final LinkRepository linkRepository;
|
||||
private final ProxyController proxyController;
|
||||
private final FetchService fetchService;
|
||||
|
||||
public ProxyServeController(LinkRepository linkRepository, ProxyController proxyController,
|
||||
FetchService fetchService) {
|
||||
this.linkRepository = linkRepository;
|
||||
this.proxyController = proxyController;
|
||||
this.fetchService = fetchService;
|
||||
}
|
||||
|
||||
@GetMapping("/proxy/{id}")
|
||||
public ResponseEntity<?> proxy(
|
||||
@PathVariable("id") String id,
|
||||
@RequestHeader(value = "Range", required = false) String rangeHeader) {
|
||||
if (id.contains("."))
|
||||
id = id.substring(0, id.lastIndexOf("."));
|
||||
Optional<Link> link = linkRepository.findById(id);
|
||||
if (link.isEmpty()) {
|
||||
return ResponseEntity.notFound().build();
|
||||
}
|
||||
String url = link.get().getUrl();
|
||||
if (url.contains(".m3u8")) {
|
||||
try {
|
||||
return proxyController.proxy(url);
|
||||
} catch (FetchFailException | PlaylistParseException e) {
|
||||
e.printStackTrace();
|
||||
return redirect(url);
|
||||
}
|
||||
}
|
||||
try {
|
||||
if (rangeHeader == null) {
|
||||
return handleFullRequest(url);
|
||||
} else {
|
||||
return handleRangeRequest(url, rangeHeader);
|
||||
}
|
||||
} catch (IOException | InterruptedException | FetchFailException e) {
|
||||
e.printStackTrace();
|
||||
return redirect(url);
|
||||
}
|
||||
}
|
||||
|
||||
private ResponseEntity<?> handleFullRequest(String url)
|
||||
throws IOException, InterruptedException, FetchFailException {
|
||||
SimpleResponse<byte[]> response = fetchService.fetchBinaryContent(url);
|
||||
HttpHeaders headers = new HttpHeaders();
|
||||
response.getHeaders().map().forEach((key, values) -> {
|
||||
headers.addAll(key, values);
|
||||
});
|
||||
return new ResponseEntity<>(response.getBody(), headers, HttpStatus.OK);
|
||||
}
|
||||
|
||||
private ResponseEntity<?> handleRangeRequest(String url, String rangeHeader)
|
||||
throws IOException, InterruptedException, FetchFailException {
|
||||
|
||||
long contentLength = fetchService.getContentLength(url);
|
||||
if (contentLength <= 0) {
|
||||
return handleFullRequest(url);
|
||||
}
|
||||
|
||||
RangeRequest range = RangeRequest.parse(rangeHeader, contentLength);
|
||||
if (range == null) {
|
||||
// Invalid range, return 416 Range Not Satisfiable
|
||||
HttpHeaders headers = new HttpHeaders();
|
||||
headers.add("Content-Range", "bytes */" + contentLength);
|
||||
return new ResponseEntity<>(headers, HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE);
|
||||
}
|
||||
|
||||
String rangeHeaderToSend = String.format("bytes=%d-%d",
|
||||
range.getStart(), range.getEnd());
|
||||
SimpleResponse<byte[]> response = fetchService.fetchBinaryContent(url, rangeHeaderToSend);
|
||||
|
||||
HttpHeaders headers = new HttpHeaders();
|
||||
response.getHeaders().map().forEach((key, values) -> {
|
||||
// Don't copy certain headers
|
||||
if (!key.equalsIgnoreCase("Transfer-Encoding") &&
|
||||
!key.equalsIgnoreCase("Connection")) {
|
||||
headers.addAll(key, values);
|
||||
}
|
||||
});
|
||||
|
||||
headers.add("Content-Range", range.toContentRangeHeader());
|
||||
headers.add("Accept-Ranges", "bytes");
|
||||
headers.setContentLength(range.getLength());
|
||||
|
||||
return new ResponseEntity<>(response.getBody(), headers, HttpStatus.PARTIAL_CONTENT);
|
||||
}
|
||||
|
||||
private ResponseEntity<?> redirect(String target) {
|
||||
HttpHeaders headers = new HttpHeaders();
|
||||
headers.setLocation(URI.create(target));
|
||||
return new ResponseEntity<>(headers, HttpStatus.MOVED_PERMANENTLY);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,17 @@
|
||||
package com.backend.hls.proxy.exception;
|
||||
|
||||
import java.net.http.HttpResponse;
|
||||
|
||||
public class FetchFailException extends Exception {
|
||||
private final HttpResponse<?> response;
|
||||
|
||||
public FetchFailException(String message, HttpResponse<?> response) {
|
||||
super(message);
|
||||
this.response = response;
|
||||
}
|
||||
|
||||
public HttpResponse<?> getResponse() {
|
||||
return response;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
package com.backend.hls.proxy.exception;
|
||||
|
||||
public class PlaylistParseException extends Exception {
|
||||
public PlaylistParseException(String message, Exception e) {
|
||||
super(message, e);
|
||||
}
|
||||
}
|
||||
40
src/main/java/com/backend/hls/proxy/model/Link.java
Normal file
40
src/main/java/com/backend/hls/proxy/model/Link.java
Normal file
@ -0,0 +1,40 @@
|
||||
package com.backend.hls.proxy.model;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.time.Duration;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import org.springframework.data.annotation.Id;
|
||||
import org.springframework.data.redis.core.RedisHash;
|
||||
import org.springframework.data.redis.core.TimeToLive;
|
||||
import org.springframework.data.redis.core.index.Indexed;
|
||||
|
||||
@RedisHash("hls-link")
|
||||
public class Link implements Serializable {
|
||||
private static final Duration TTL = Duration.ofDays(1);
|
||||
|
||||
@Id
|
||||
private String id;
|
||||
@TimeToLive(unit = TimeUnit.SECONDS)
|
||||
private Long expirationSeconds;
|
||||
@Indexed
|
||||
private String url;
|
||||
|
||||
Link() {
|
||||
}
|
||||
|
||||
public Link(String id, String url) {
|
||||
this.id = id;
|
||||
this.url = url;
|
||||
this.expirationSeconds = TTL.toSeconds();
|
||||
}
|
||||
|
||||
public String getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public String getUrl() {
|
||||
return url;
|
||||
}
|
||||
|
||||
}
|
||||
74
src/main/java/com/backend/hls/proxy/model/RangeRequest.java
Normal file
74
src/main/java/com/backend/hls/proxy/model/RangeRequest.java
Normal file
@ -0,0 +1,74 @@
|
||||
package com.backend.hls.proxy.model;
|
||||
|
||||
public class RangeRequest {
|
||||
private final long start;
|
||||
private final long end;
|
||||
private final long total;
|
||||
|
||||
public RangeRequest(long start, long end, long total) {
|
||||
this.start = start;
|
||||
this.end = end;
|
||||
this.total = total;
|
||||
}
|
||||
|
||||
public static RangeRequest parse(String rangeHeader, long contentLength) {
|
||||
if (rangeHeader == null || !rangeHeader.startsWith("bytes=")) {
|
||||
return null;
|
||||
}
|
||||
|
||||
try {
|
||||
String range = rangeHeader.substring(6); // Remove "bytes="
|
||||
String[] parts = range.split("-");
|
||||
|
||||
long start = 0;
|
||||
long end = contentLength - 1;
|
||||
|
||||
if (parts.length == 1) {
|
||||
if (range.startsWith("-")) {
|
||||
// Last N bytes
|
||||
long suffix = Long.parseLong(parts[0]);
|
||||
start = Math.max(0, contentLength + suffix);
|
||||
} else {
|
||||
// From start to end
|
||||
start = Long.parseLong(parts[0]);
|
||||
}
|
||||
} else if (parts.length == 2) {
|
||||
// Range: bytes=500-999
|
||||
start = Long.parseLong(parts[0]);
|
||||
if (!parts[1].isEmpty()) {
|
||||
end = Long.parseLong(parts[1]);
|
||||
}
|
||||
}
|
||||
|
||||
if (start > end || start >= contentLength) {
|
||||
return null;
|
||||
}
|
||||
|
||||
end = Math.min(end, contentLength - 1);
|
||||
return new RangeRequest(start, end, contentLength);
|
||||
|
||||
} catch (NumberFormatException e) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public long getStart() {
|
||||
return start;
|
||||
}
|
||||
|
||||
public long getEnd() {
|
||||
return end;
|
||||
}
|
||||
|
||||
public long getTotal() {
|
||||
return total;
|
||||
}
|
||||
|
||||
public long getLength() {
|
||||
return end - start + 1;
|
||||
}
|
||||
|
||||
public String toContentRangeHeader() {
|
||||
return String.format("bytes %d-%d/%d", start, end, total);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,22 @@
|
||||
package com.backend.hls.proxy.model;
|
||||
|
||||
import java.net.http.HttpHeaders;
|
||||
|
||||
public class SimpleResponse<T> {
|
||||
private final T body;
|
||||
private final HttpHeaders headers;
|
||||
|
||||
public SimpleResponse(T body, HttpHeaders headers) {
|
||||
this.body = body;
|
||||
this.headers = headers;
|
||||
}
|
||||
|
||||
public T getBody() {
|
||||
return body;
|
||||
}
|
||||
|
||||
public HttpHeaders getHeaders() {
|
||||
return headers;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
package com.backend.hls.proxy.repository;
|
||||
|
||||
import java.util.Optional;
|
||||
|
||||
import org.springframework.data.repository.CrudRepository;
|
||||
import org.springframework.stereotype.Repository;
|
||||
|
||||
import com.backend.hls.proxy.model.Link;
|
||||
|
||||
@Repository
|
||||
public interface LinkRepository extends CrudRepository<Link, String> {
|
||||
Optional<Link> findFirstByUrl(String url);
|
||||
}
|
||||
107
src/main/java/com/backend/hls/proxy/service/FetchService.java
Normal file
107
src/main/java/com/backend/hls/proxy/service/FetchService.java
Normal file
@ -0,0 +1,107 @@
|
||||
package com.backend.hls.proxy.service;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.URI;
|
||||
import java.net.http.HttpClient;
|
||||
import java.net.http.HttpRequest;
|
||||
import java.net.http.HttpResponse;
|
||||
import java.time.Duration;
|
||||
|
||||
import org.springframework.cache.annotation.Cacheable;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
import com.backend.hls.proxy.exception.FetchFailException;
|
||||
import com.backend.hls.proxy.model.SimpleResponse;
|
||||
|
||||
@Service
|
||||
public class FetchService {
|
||||
private final HttpClient httpClient;
|
||||
|
||||
public FetchService(HttpClient httpClient) {
|
||||
this.httpClient = httpClient;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch text content from URL
|
||||
*
|
||||
* @throws FetchFailException
|
||||
*/
|
||||
@Cacheable("hlsPlaylistContent")
|
||||
public String fetchTextContent(String url) throws IOException, InterruptedException, FetchFailException {
|
||||
HttpRequest request = HttpRequest.newBuilder()
|
||||
.uri(URI.create(url))
|
||||
.build();
|
||||
|
||||
HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
|
||||
|
||||
if (response.statusCode() != 200) {
|
||||
throw new FetchFailException("Failed to fetch content from " + url + ", status: " + response.statusCode(),
|
||||
response);
|
||||
}
|
||||
|
||||
return response.body();
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch binary content from URL
|
||||
*
|
||||
* @throws FetchFailException
|
||||
*/
|
||||
@Cacheable("playlistSegmentContent")
|
||||
public SimpleResponse<byte[]> fetchBinaryContent(String url)
|
||||
throws IOException, InterruptedException, FetchFailException {
|
||||
return fetchBinaryContent(url, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch binary content from URL
|
||||
*
|
||||
* @throws FetchFailException
|
||||
*/
|
||||
@Cacheable("playlistSegmentContent")
|
||||
public SimpleResponse<byte[]> fetchBinaryContent(String url, String rangeHeader)
|
||||
throws IOException, InterruptedException, FetchFailException {
|
||||
HttpRequest.Builder builder = HttpRequest.newBuilder()
|
||||
.uri(URI.create(url));
|
||||
|
||||
if (rangeHeader != null && !rangeHeader.isEmpty()) {
|
||||
builder.header("Range", rangeHeader);
|
||||
}
|
||||
|
||||
HttpResponse<byte[]> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofByteArray());
|
||||
|
||||
if (response.statusCode() >= 400) {
|
||||
throw new FetchFailException("Failed to fetch content from " + url + ", status: " + response.statusCode(),
|
||||
response);
|
||||
}
|
||||
|
||||
return new SimpleResponse<byte[]>(response.body(), response.headers());
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch content length
|
||||
*
|
||||
* @throws FetchFailException
|
||||
*/
|
||||
public long getContentLength(String url)
|
||||
throws IOException, InterruptedException, FetchFailException {
|
||||
|
||||
HttpRequest request = HttpRequest.newBuilder()
|
||||
.uri(URI.create(url))
|
||||
.method("HEAD", HttpRequest.BodyPublishers.noBody())
|
||||
.timeout(Duration.ofSeconds(10))
|
||||
.build();
|
||||
|
||||
HttpResponse<Void> response = httpClient.send(request,
|
||||
HttpResponse.BodyHandlers.discarding());
|
||||
|
||||
if (response.statusCode() >= 400) {
|
||||
throw new FetchFailException("HTTP " + response.statusCode(), response);
|
||||
}
|
||||
|
||||
return response.headers()
|
||||
.firstValueAsLong("Content-Length")
|
||||
.orElse(-1L);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,52 @@
|
||||
package com.backend.hls.proxy.service;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
import com.backend.hls.proxy.exception.FetchFailException;
|
||||
import com.backend.hls.proxy.exception.PlaylistParseException;
|
||||
|
||||
import io.lindstrom.m3u8.model.MediaPlaylist;
|
||||
import io.lindstrom.m3u8.model.MultivariantPlaylist;
|
||||
import io.lindstrom.m3u8.parser.MediaPlaylistParser;
|
||||
import io.lindstrom.m3u8.parser.MultivariantPlaylistParser;
|
||||
|
||||
@Service
|
||||
public class PlaylistParseService {
|
||||
private final FetchService fetchService;
|
||||
private final MultivariantPlaylistParser playlistParser;
|
||||
private final MediaPlaylistParser mediaParser;
|
||||
|
||||
public PlaylistParseService(FetchService fetchService, MultivariantPlaylistParser playlistParser,
|
||||
MediaPlaylistParser mediaParser) {
|
||||
this.fetchService = fetchService;
|
||||
this.playlistParser = playlistParser;
|
||||
this.mediaParser = mediaParser;
|
||||
}
|
||||
|
||||
public MultivariantPlaylist readMultivariantPlaylist(String m3u8URL)
|
||||
throws PlaylistParseException, FetchFailException {
|
||||
try {
|
||||
return playlistParser.readPlaylist(fetchService.fetchTextContent(m3u8URL));
|
||||
} catch (IOException | InterruptedException e) {
|
||||
throw new PlaylistParseException("Failed to read playlist from " + m3u8URL, e);
|
||||
}
|
||||
}
|
||||
|
||||
public MediaPlaylist readMediaPlaylist(String m3u8URL) throws PlaylistParseException, FetchFailException {
|
||||
try {
|
||||
return mediaParser.readPlaylist(fetchService.fetchTextContent(m3u8URL));
|
||||
} catch (IOException | InterruptedException e) {
|
||||
throw new PlaylistParseException("Failed to read playlist from " + m3u8URL, e);
|
||||
}
|
||||
}
|
||||
|
||||
public String writeAsString(MultivariantPlaylist proxiedPlaylist) {
|
||||
return playlistParser.writePlaylistAsString(proxiedPlaylist);
|
||||
}
|
||||
|
||||
public String writeAsString(MediaPlaylist proxiedPlaylist) {
|
||||
return mediaParser.writePlaylistAsString(proxiedPlaylist);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,170 @@
|
||||
package com.backend.hls.proxy.service;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
import com.backend.hls.proxy.exception.FetchFailException;
|
||||
import com.backend.hls.proxy.exception.PlaylistParseException;
|
||||
|
||||
import io.lindstrom.m3u8.model.AlternativeRendition;
|
||||
import io.lindstrom.m3u8.model.MediaPlaylist;
|
||||
import io.lindstrom.m3u8.model.MediaSegment;
|
||||
import io.lindstrom.m3u8.model.MultivariantPlaylist;
|
||||
import io.lindstrom.m3u8.model.PartialSegment;
|
||||
import io.lindstrom.m3u8.model.SegmentMap;
|
||||
import io.lindstrom.m3u8.model.Variant;
|
||||
|
||||
@Service
|
||||
public class PlaylistProxyService {
|
||||
private static final Logger logger = LoggerFactory.getLogger(PlaylistProxyService.class);
|
||||
private final PlaylistParseService playlistParseService;
|
||||
private final URLForwardService urlForwardService;
|
||||
|
||||
public PlaylistProxyService(PlaylistParseService playlistParseService, URLForwardService urlForwardService) {
|
||||
this.playlistParseService = playlistParseService;
|
||||
this.urlForwardService = urlForwardService;
|
||||
}
|
||||
|
||||
public String proxyPlaylist(String hlsUrl, String proxyUrl)
|
||||
throws FetchFailException {
|
||||
String base = hlsUrl.substring(0, hlsUrl.lastIndexOf('/') + 1);
|
||||
String suffix = hlsUrl.substring(hlsUrl.lastIndexOf('/') + 1);
|
||||
String url = base + suffix;
|
||||
try {
|
||||
MultivariantPlaylist playlist = playlistParseService.readMultivariantPlaylist(url);
|
||||
|
||||
List<Variant> variants = playlist.variants()
|
||||
.stream()
|
||||
.map(variant -> proxyVariant(variant, base, proxyUrl))
|
||||
.collect(Collectors.toList());
|
||||
List<AlternativeRendition> alternativeRenditions = playlist.alternativeRenditions()
|
||||
.stream()
|
||||
.map(rendition -> proxyRendition(rendition, base, proxyUrl))
|
||||
.collect(Collectors.toList());
|
||||
|
||||
MultivariantPlaylist proxiedPlaylist = MultivariantPlaylist.builder()
|
||||
.from(playlist)
|
||||
.variants(variants)
|
||||
.alternativeRenditions(alternativeRenditions)
|
||||
.build();
|
||||
return playlistParseService.writeAsString(proxiedPlaylist);
|
||||
} catch (PlaylistParseException e) {
|
||||
}
|
||||
try {
|
||||
MediaPlaylist playlist = playlistParseService.readMediaPlaylist(url);
|
||||
|
||||
List<MediaSegment> mediaSegments = playlist.mediaSegments()
|
||||
.stream()
|
||||
.map(segment -> proxySegment(segment, base, proxyUrl))
|
||||
.collect(Collectors.toList());
|
||||
|
||||
List<PartialSegment> partialSegments = playlist.partialSegments()
|
||||
.stream()
|
||||
.map(segment -> proxyPartialSegment(segment, base, proxyUrl))
|
||||
.collect(Collectors.toList());
|
||||
|
||||
logger.info("media playlist " + playlist.variables() + " " + playlist.partialSegmentInformation());
|
||||
mediaSegments.forEach(segment -> logger.info("segment map " + segment.segmentMap()));
|
||||
|
||||
MediaPlaylist proxiedPlaylist = MediaPlaylist.builder()
|
||||
.from(playlist)
|
||||
.mediaSegments(mediaSegments)
|
||||
.partialSegments(partialSegments)
|
||||
.build();
|
||||
|
||||
return playlistParseService.writeAsString(proxiedPlaylist);
|
||||
} catch (PlaylistParseException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
throw new IllegalStateException("Unknown playlist format");
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a variant and rewrite its URI
|
||||
*/
|
||||
private Variant proxyVariant(Variant variant, String base, String proxyUrl) {
|
||||
if (variant.uri() == null) {
|
||||
logger.error("cannot proxy variant: {}", variant);
|
||||
return variant;
|
||||
}
|
||||
String variantUri = base + variant.uri();
|
||||
String proxiedUri = urlForwardService.createForwarded(variantUri);
|
||||
return Variant.builder()
|
||||
.from(variant)
|
||||
.uri(proxiedUri)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a rendition and rewrite its URI
|
||||
*/
|
||||
private AlternativeRendition proxyRendition(AlternativeRendition rendition, String base, String proxyUrl) {
|
||||
if (rendition.uri().isEmpty()) {
|
||||
return rendition;
|
||||
}
|
||||
String renditionUri = base + rendition.uri().get();
|
||||
String proxiedUri = urlForwardService.createForwarded(renditionUri);
|
||||
return AlternativeRendition.builder()
|
||||
.from(rendition)
|
||||
.uri(proxiedUri)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a segment and rewrite its URI
|
||||
*/
|
||||
private MediaSegment proxySegment(MediaSegment segment, String base, String proxyUrl) {
|
||||
if (segment.uri() == null) {
|
||||
logger.error("cannot proxy segment: {}", segment);
|
||||
return segment;
|
||||
}
|
||||
|
||||
String segmentUri = base + segment.uri();
|
||||
String proxiedUri = urlForwardService.createForwarded(segmentUri);
|
||||
|
||||
MediaSegment.Builder builder = MediaSegment.builder()
|
||||
.from(segment)
|
||||
.uri(proxiedUri);
|
||||
if (segment.segmentMap().isPresent()) {
|
||||
builder.segmentMap(proxySegmentMap(segment.segmentMap().get(), base, proxyUrl));
|
||||
}
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a partial segment and rewrite its URI
|
||||
*/
|
||||
private PartialSegment proxyPartialSegment(PartialSegment segment, String base, String proxyUrl) {
|
||||
if (segment.uri() == null) {
|
||||
logger.error("cannot proxy segment: {}", segment);
|
||||
return segment;
|
||||
}
|
||||
String segmentUri = base + segment.uri();
|
||||
String proxiedUri = urlForwardService.createForwarded(segmentUri);
|
||||
return PartialSegment.builder()
|
||||
.from(segment)
|
||||
.uri(proxiedUri)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a segment map and rewrite its URI
|
||||
*/
|
||||
private SegmentMap proxySegmentMap(SegmentMap segmentMap, String base, String proxyUrl) {
|
||||
if (segmentMap.uri() == null) {
|
||||
logger.error("cannot proxy segment: {}", segmentMap);
|
||||
return segmentMap;
|
||||
}
|
||||
String segmentMapUri = base + segmentMap.uri();
|
||||
String proxiedUri = urlForwardService.createForwarded(segmentMapUri);
|
||||
return SegmentMap.builder()
|
||||
.from(segmentMap)
|
||||
.uri(proxiedUri)
|
||||
.build();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,39 @@
|
||||
package com.backend.hls.proxy.service;
|
||||
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
import com.backend.hls.proxy.model.Link;
|
||||
import com.backend.hls.proxy.repository.LinkRepository;
|
||||
|
||||
@Service
|
||||
public class URLForwardService {
|
||||
private final LinkRepository linkRepository;
|
||||
|
||||
public URLForwardService(LinkRepository linkRepository) {
|
||||
this.linkRepository = linkRepository;
|
||||
}
|
||||
|
||||
public String createForwarded(String originalUrl) {
|
||||
String suffix = "";
|
||||
if (originalUrl.contains(".")) {
|
||||
suffix = originalUrl.substring(originalUrl.lastIndexOf("."));
|
||||
}
|
||||
|
||||
Optional<Link> existingLink = linkRepository.findFirstByUrl(originalUrl);
|
||||
if (existingLink.isPresent()) {
|
||||
return wrapId(existingLink.get().getId() + suffix);
|
||||
}
|
||||
UUID uuid = UUID.randomUUID();
|
||||
linkRepository.save(new Link(uuid.toString(), originalUrl));
|
||||
|
||||
return wrapId(uuid.toString() + suffix);
|
||||
}
|
||||
|
||||
private String wrapId(String id) {
|
||||
return "/proxy/" + id;
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user