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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright (c) 2017-present Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
package app
import (
"os"
"strings"
l4g "github.com/alecthomas/log4go"
"github.com/mattermost/platform/model"
"github.com/mattermost/platform/utils"
)
func LoadLicense() {
utils.RemoveLicense()
licenseId := ""
if result := <-Srv.Store.System().Get(); result.Err == nil {
props := result.Data.(model.StringMap)
licenseId = props[model.SYSTEM_ACTIVE_LICENSE_ID]
}
if len(licenseId) != 26 {
// Lets attempt to load the file from disk since it was missing from the DB
fileName := utils.GetLicenseFileLocation(*utils.Cfg.ServiceSettings.LicenseFileLocation)
if _, err := os.Stat(fileName); err == nil {
l4g.Info("License key has not been uploaded. Loading license key from disk at %v", fileName)
licenseBytes := utils.GetLicenseFileFromDisk(fileName)
if success, licenseStr := utils.ValidateLicense(licenseBytes); success {
licenseFileFromDisk := model.LicenseFromJson(strings.NewReader(licenseStr))
licenseId = licenseFileFromDisk.Id
if _, err := SaveLicense(licenseBytes); err != nil {
l4g.Info("Failed to save license key loaded from disk err=%v", err.Error())
return
}
} else {
l4g.Error("Found license key at %v but it appears to be invalid.", fileName)
return
}
} else {
l4g.Info(utils.T("mattermost.load_license.find.warn"))
l4g.Debug("We could not find the license key in the database or on disk at %v", fileName)
return
}
}
if result := <-Srv.Store.License().Get(licenseId); result.Err == nil {
record := result.Data.(*model.LicenseRecord)
utils.LoadLicense([]byte(record.Bytes))
l4g.Info("License key valid unlocking enterprise features.")
} else {
l4g.Info(utils.T("mattermost.load_license.find.warn"))
}
}
func SaveLicense(licenseBytes []byte) (*model.License, *model.AppError) {
var license *model.License
if success, licenseStr := utils.ValidateLicense(licenseBytes); success {
license = model.LicenseFromJson(strings.NewReader(licenseStr))
if result := <-Srv.Store.User().AnalyticsUniqueUserCount(""); result.Err != nil {
return nil, model.NewLocAppError("addLicense", "api.license.add_license.invalid_count.app_error", nil, result.Err.Error())
} else {
uniqueUserCount := result.Data.(int64)
if uniqueUserCount > int64(*license.Features.Users) {
return nil, model.NewLocAppError("addLicense", "api.license.add_license.unique_users.app_error", map[string]interface{}{"Users": *license.Features.Users, "Count": uniqueUserCount}, "")
}
}
if ok := utils.SetLicense(license); !ok {
return nil, model.NewLocAppError("addLicense", model.EXPIRED_LICENSE_ERROR, nil, "")
}
record := &model.LicenseRecord{}
record.Id = license.Id
record.Bytes = string(licenseBytes)
rchan := Srv.Store.License().Save(record)
if result := <-rchan; result.Err != nil {
RemoveLicense()
return nil, model.NewLocAppError("addLicense", "api.license.add_license.save.app_error", nil, "err="+result.Err.Error())
}
sysVar := &model.System{}
sysVar.Name = model.SYSTEM_ACTIVE_LICENSE_ID
sysVar.Value = license.Id
schan := Srv.Store.System().SaveOrUpdate(sysVar)
if result := <-schan; result.Err != nil {
RemoveLicense()
return nil, model.NewLocAppError("addLicense", "api.license.add_license.save_active.app_error", nil, "")
}
} else {
return nil, model.NewLocAppError("addLicense", model.INVALID_LICENSE_ERROR, nil, "")
}
ReloadConfig()
InvalidateAllCaches()
return license, nil
}
func RemoveLicense() *model.AppError {
utils.RemoveLicense()
sysVar := &model.System{}
sysVar.Name = model.SYSTEM_ACTIVE_LICENSE_ID
sysVar.Value = ""
if result := <-Srv.Store.System().SaveOrUpdate(sysVar); result.Err != nil {
utils.RemoveLicense()
return result.Err
}
ReloadConfig()
InvalidateAllCaches()
return nil
}
|
