Merge pull request #142 from Julian-Chu/add_decipherOperationsCache

Add decipher operations cache

Author: Julian-Chu

client.go

@@ -16,6 +16,9 @@ type Client struct {
 	// HTTPClient can be used to set a custom HTTP client.
 	// If not set, http.DefaultClient will be used
 	HTTPClient *http.Client
+
+	// decipherOpsCache cache decipher operations
+	decipherOpsCache DecipherOperationsCache
 }
 
 // GetVideo fetches video metadata

decipher.go

@@ -37,7 +37,7 @@ func (c *Client) decipherURL(ctx context.Context, videoID string, cipher string)
 		return a.join("")
 	*/
 
-	operations, err := c.parseDecipherOps(ctx, videoID)
+	operations, err := c.parseDecipherOpsWithCache(ctx, videoID)
 	if err != nil {
 		return "", err
 	}
@@ -83,7 +83,7 @@ var (
 	swapRegexp    = regexp.MustCompile(fmt.Sprintf("(?m)(?:^|,)(%s)%s", jsvarStr, swapStr))
 )
 
-func (c *Client) parseDecipherOps(ctx context.Context, videoID string) (operations []operation, err error) {
+func (c *Client) parseDecipherOps(ctx context.Context, videoID string) (operations []DecipherOperation, err error) {
 	embedURL := fmt.Sprintf("https://youtube.com/embed/%s?hl=en", videoID)
 	embedBody, err := c.httpGetBodyBytes(ctx, embedURL)
 	if err != nil {
@@ -129,7 +129,7 @@ func (c *Client) parseDecipherOps(ctx context.Context, videoID string) (operatio
 		return nil, err
 	}
 
-	var ops []operation
+	var ops []DecipherOperation
 	for _, s := range regex.FindAllSubmatch(funcBody, -1) {
 		switch string(s[1]) {
 		case reverseKey:
@@ -144,3 +144,21 @@ func (c *Client) parseDecipherOps(ctx context.Context, videoID string) (operatio
 	}
 	return ops, nil
 }
+
+func (c *Client) parseDecipherOpsWithCache(ctx context.Context, videoID string) (operations []DecipherOperation, err error) {
+	if c.decipherOpsCache == nil {
+		c.decipherOpsCache = NewSimpleCache()
+	}
+
+	if ops := c.decipherOpsCache.Get(videoID); ops != nil {
+		return ops, nil
+	}
+
+	ops, err := c.parseDecipherOps(ctx, videoID)
+	if err != nil {
+		return nil, err
+	}
+
+	c.decipherOpsCache.Set(videoID, ops)
+	return ops, err
+}

decipher_operations.go

@@ -1,14 +1,14 @@
 package youtube
 
-type operation func([]byte) []byte
+type DecipherOperation func([]byte) []byte
 
-func newSpliceFunc(pos int) operation {
+func newSpliceFunc(pos int) DecipherOperation {
 	return func(bs []byte) []byte {
 		return bs[pos:]
 	}
 }
 
-func newSwapFunc(arg int) operation {
+func newSwapFunc(arg int) DecipherOperation {
 	return func(bs []byte) []byte {
 		pos := arg % len(bs)
 		bs[0], bs[pos] = bs[pos], bs[0]

decipher_operations_cache.go

@@ -0,0 +1,51 @@
+package youtube
+
+import "time"
+
+var (
+	_ DecipherOperationsCache = NewSimpleCache()
+)
+
+const defaultCacheExpiration = time.Minute * time.Duration(5)
+
+type DecipherOperationsCache interface {
+	Get(videoID string) []DecipherOperation
+	Set(video string, operations []DecipherOperation)
+}
+
+type SimpleCache struct {
+	videoID    string
+	expiredAt  time.Time
+	operations []DecipherOperation
+}
+
+func NewSimpleCache() *SimpleCache {
+	return &SimpleCache{}
+}
+
+// Get : get cache  when it has same video id and not expired
+func (s SimpleCache) Get(videoID string) []DecipherOperation {
+	return s.GetCacheBefore(videoID, time.Now())
+}
+
+// GetCacheBefore : can pass time for testing
+func (s SimpleCache) GetCacheBefore(videoID string, time time.Time) []DecipherOperation {
+	if videoID == s.videoID && s.expiredAt.After(time) {
+		operations := make([]DecipherOperation, len(s.operations))
+		copy(operations, s.operations)
+		return operations
+	}
+	return nil
+}
+
+// Set : set cache with default expiration
+func (s *SimpleCache) Set(videoID string, operations []DecipherOperation) {
+	s.setWithExpiredTime(videoID, operations, time.Now().Add(defaultCacheExpiration))
+}
+
+func (s *SimpleCache) setWithExpiredTime(videoID string, operations []DecipherOperation, time time.Time) {
+	s.videoID = videoID
+	s.operations = make([]DecipherOperation, len(operations))
+	copy(s.operations, operations)
+	s.expiredAt = time
+}

decipher_operations_cache_test.go

@@ -0,0 +1,68 @@
+package youtube
+
+import (
+	"testing"
+	"time"
+)
+
+func TestSimpleCache(t *testing.T) {
+	type args struct {
+		setVideoID string
+		getVideoID string
+		operations []DecipherOperation
+		expiredAt  string
+		getCacheAt string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []DecipherOperation
+	}{
+		{
+			name: "Get cache data with video id",
+			args: args{
+				setVideoID: "test",
+				getVideoID: "test",
+				operations: []DecipherOperation{func(bytes []byte) []byte { return nil }},
+				expiredAt:  "2021-01-01 00:01:00",
+				getCacheAt: "2021-01-01 00:00:00",
+			},
+			want: []DecipherOperation{func(bytes []byte) []byte { return nil }},
+		},
+		{
+			name: "Get nil when cache is expired",
+			args: args{
+				setVideoID: "test",
+				getVideoID: "test",
+				operations: []DecipherOperation{func(bytes []byte) []byte { return nil }},
+				expiredAt:  "2021-01-01 00:00:00",
+				getCacheAt: "2021-01-01 00:00:00",
+			},
+			want: nil,
+		},
+		{
+			name: "Get nil when video id is not cached",
+			args: args{
+				setVideoID: "test",
+				getVideoID: "not test",
+				operations: []DecipherOperation{func(bytes []byte) []byte { return nil }},
+				expiredAt:  "2021-01-01 00:00:01",
+				getCacheAt: "2021-01-01 00:00:00",
+			},
+			want: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := NewSimpleCache()
+			timeFormat := "2006-01-02 15:04:05"
+			expiredAt, _ := time.Parse(timeFormat, tt.args.expiredAt)
+			s.setWithExpiredTime(tt.args.setVideoID, tt.args.operations, expiredAt)
+			getCacheAt, _ := time.Parse(timeFormat, tt.args.getCacheAt)
+			if got := s.GetCacheBefore(tt.args.getVideoID, getCacheAt); len(got) != len(tt.want) {
+				t.Errorf("GetCacheBefore() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}