/
compression.go
executable file
·106 lines (88 loc) · 3.09 KB
/
compression.go
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
100
101
102
103
104
105
106
//
// Copyright (c) 2017 Cavium
// Copyright (c) 2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package transforms
import (
"bytes"
"compress/gzip"
"compress/zlib"
"encoding/base64"
"errors"
"github.com/edgexfoundry/go-mod-core-contracts/clients"
"github.com/epcom-hdxt/app-functions-sdk-go/appcontext"
"github.com/epcom-hdxt/app-functions-sdk-go/pkg/util"
)
type Compression struct {
gzipWriter *gzip.Writer
zlibWriter *zlib.Writer
}
// NewCompression creates, initializes and returns a new instance of Compression
func NewCompression() Compression {
return Compression{}
}
// CompressWithGZIP compresses data received as either a string,[]byte, or json.Marshaler using gzip algorithm
// and returns a base64 encoded string as a []byte.
func (compression *Compression) CompressWithGZIP(edgexcontext *appcontext.Context, params ...interface{}) (bool, interface{}) {
if len(params) < 1 {
// We didn't receive a result
return false, errors.New("No Data Received")
}
edgexcontext.LoggingClient.Debug("Compression with GZIP")
data, err := util.CoerceType(params[0])
if err != nil {
return false, err
}
var buf bytes.Buffer
if compression.gzipWriter == nil {
compression.gzipWriter = gzip.NewWriter(&buf)
} else {
compression.gzipWriter.Reset(&buf)
}
compression.gzipWriter.Write([]byte(data))
compression.gzipWriter.Close()
// Set response "content-type" header to "text/plain"
edgexcontext.ResponseContentType = clients.ContentTypeText
return true, bytesBufferToBase64(buf)
}
// CompressWithZLIB compresses data received as either a string,[]byte, or json.Marshaler using zlib algorithm
// and returns a base64 encoded string as a []byte.
func (compression *Compression) CompressWithZLIB(edgexcontext *appcontext.Context, params ...interface{}) (bool, interface{}) {
if len(params) < 1 {
// We didn't receive a result
return false, errors.New("No Data Received")
}
edgexcontext.LoggingClient.Debug("Compression with ZLIB")
data, err := util.CoerceType(params[0])
if err != nil {
return false, err
}
var buf bytes.Buffer
if compression.zlibWriter == nil {
compression.zlibWriter = zlib.NewWriter(&buf)
} else {
compression.zlibWriter.Reset(&buf)
}
compression.zlibWriter.Write([]byte(data))
compression.zlibWriter.Close()
// Set response "content-type" header to "text/plain"
edgexcontext.ResponseContentType = clients.ContentTypeText
return true, bytesBufferToBase64(buf)
}
func bytesBufferToBase64(buf bytes.Buffer) []byte {
dst := make([]byte, base64.StdEncoding.EncodedLen(buf.Len()))
base64.StdEncoding.Encode(dst, buf.Bytes())
return dst
}