aboutsummaryrefslogtreecommitdiff
path: root/Timeline/Services/TencentCloudCosService.cs
blob: 9ab9d54d6c742bf446eba53d216207aba4bc0d0b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
using COSXML;
using COSXML.Auth;
using COSXML.CosException;
using COSXML.Model;
using COSXML.Model.Object;
using COSXML.Model.Tag;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Threading.Tasks;
using Timeline.Configs;

namespace Timeline.Services
{
    public interface ITencentCloudCosService
    {
        Task<bool> Exists(string bucket, string key);
        string GetObjectUrl(string bucket, string key);
    }

    public class TencentCloudCosService : ITencentCloudCosService
    {
        private readonly TencentCosConfig _config;
        private readonly CosXmlServer _server;
        private readonly ILogger<TencentCloudCosService> _logger;

        public TencentCloudCosService(IOptions<TencentCosConfig> config, ILogger<TencentCloudCosService> logger)
        {
            _config = config.Value;
            _logger = logger;

            var cosConfig = new CosXmlConfig.Builder()
                .IsHttps(true)
                .SetAppid(config.Value.AppId)
                .SetRegion(config.Value.Region)
                .SetDebugLog(true)
                .Build();

            var credentialProvider = new DefaultQCloudCredentialProvider(config.Value.SecretId, config.Value.SecretKey, 3600);

            _server = new CosXmlServer(cosConfig, credentialProvider);
        }

        public Task<bool> Exists(string bucket, string key)
        {
            bucket = bucket + "-" + _config.AppId;

            var request = new HeadObjectRequest(bucket, key);

            var t = new TaskCompletionSource<bool>();

            _server.HeadObject(request, delegate (CosResult result)
            {
                if (result.httpCode >= 200 && result.httpCode < 300)
                    t.TrySetResult(true);
                else
                    t.TrySetResult(false);
            },
            delegate (CosClientException clientException, CosServerException serverException)
            {
                if (clientException != null)
                {
                    _logger.LogError(clientException, "An client error occured when test cos object existence. Bucket : {} . Key : {} .", bucket, key);
                    t.TrySetException(clientException);
                    return;
                }
                if (serverException != null)
                {
                    if (serverException.statusCode == 404)
                    {
                        t.TrySetResult(false);
                        return;
                    }
                    _logger.LogError(serverException, "An server error occured when test cos object existence. Bucket : {} . Key : {} .", bucket, key);
                    t.TrySetException(serverException);
                    return;
                }
                _logger.LogError("An unknown error occured when test cos object existence. Bucket : {} . Key : {} .", bucket, key);
                t.TrySetException(new Exception("Unknown exception when test cos object existence."));
            });

            return t.Task;
        }

        public string GetObjectUrl(string bucket, string key)
        {
            return _server.GenerateSignURL(new PreSignatureStruct()
            {
                appid = _config.AppId,
                region = _config.Region,
                bucket = bucket + "-" + _config.AppId,
                key = key,
                httpMethod = "GET",
                isHttps = true,
                signDurationSecond = 300
            });
        }
    }
}