// Subscribes a customer to a new plan.
//
// see https://stripe.com/docs/api#update_subscription
func (self *SubscriptionClient) Update(customerId string, params *SubscriptionParams) (*Subscription, error) {
values := url.Values{"plan": {params.Plan}}
// set optional parameters
if len(params.Coupon) != 0 {
values.Add("coupon", params.Coupon)
}
if params.Prorate {
values.Add("prorate", "true")
}
if params.TrialEnd != 0 {
values.Add("trial_end", strconv.FormatInt(params.TrialEnd, 10))
}
if params.Quantity != 0 {
values.Add("quantity", strconv.FormatInt(params.Quantity, 10))
}
// attach a new card, if requested
if len(params.Token) != 0 {
values.Add("card", params.Token)
} else if params.Card != nil {
appendCardParamsToValues(params.Card, &values)
}
s := Subscription{}
path := "/v1/customers/" + url.QueryEscape(customerId) + "/subscription"
err := query("POST", path, values, &s)
return &s, err
}
// human friendly version string - major.minor.patch
func (v Version) String() string {
return strings.Join(([]string{
strconv.FormatInt(v.Major, BASE10),
strconv.FormatInt(v.Minor, BASE10),
strconv.FormatInt(v.Patch, BASE10)}),
SEPARATOR)
}
func joinCpu(c *configs.Cgroup, pid int) error {
path, err := getSubsystemPath(c, "cpu")
if err != nil && !cgroups.IsNotFound(err) {
return err
}
if c.CpuQuota != 0 {
if err = writeFile(path, "cpu.cfs_quota_us", strconv.FormatInt(c.CpuQuota, 10)); err != nil {
return err
}
}
if c.CpuPeriod != 0 {
if err = writeFile(path, "cpu.cfs_period_us", strconv.FormatInt(c.CpuPeriod, 10)); err != nil {
return err
}
}
if c.CpuRtPeriod != 0 {
if err = writeFile(path, "cpu.rt_period_us", strconv.FormatInt(c.CpuRtPeriod, 10)); err != nil {
return err
}
}
if c.CpuRtRuntime != 0 {
if err = writeFile(path, "cpu.rt_runtime_us", strconv.FormatInt(c.CpuRtRuntime, 10)); err != nil {
return err
}
}
return nil
}
// UpdateAutoScalingGroup updates the scaling group.
//
// To update an auto scaling group with a launch configuration that has the InstanceMonitoring
// flag set to False, you must first ensure that collection of group metrics is disabled.
// Otherwise calls to UpdateAutoScalingGroup will fail.
func (as *AutoScaling) UpdateAutoScalingGroup(ag AutoScalingGroup) (resp *SimpleResp, err error) {
resp = &SimpleResp{}
params := makeParams("UpdateAutoScalingGroup")
params["AutoScalingGroupName"] = ag.AutoScalingGroupName
addParamsList(params, "AvailabilityZones.member", ag.AvailabilityZones)
if ag.DefaultCooldown > 0 {
params["DefaultCooldown"] = strconv.FormatInt(ag.DefaultCooldown, 10)
}
params["DesiredCapacity"] = strconv.FormatInt(ag.DesiredCapacity, 10)
if ag.HealthCheckGracePeriod > 0 {
params["HealthCheckGracePeriod"] = strconv.FormatInt(ag.HealthCheckGracePeriod, 10)
}
if ag.HealthCheckType == "ELB" {
params["HealthCheckType"] = ag.HealthCheckType
}
params["LaunchConfigurationName"] = ag.LaunchConfigurationName
if ag.MaxSize > 0 {
params["MaxSize"] = strconv.FormatInt(ag.MaxSize, 10)
}
if ag.MinSize > 0 {
params["MinSize"] = strconv.FormatInt(ag.MinSize, 10)
}
if len(ag.TerminationPolicies) > 0 {
addParamsList(params, "TerminationPolicies.member", ag.TerminationPolicies)
}
if len(ag.VPCZoneIdentifier) > 0 {
params["VPCZoneIdentifier"] = ag.VPCZoneIdentifier
}
err = as.query(params, resp)
if err != nil {
return nil, err
}
return resp, nil
}
func newLabels(container *api.Container, pod *api.Pod, restartCount int) map[string]string {
labels := map[string]string{}
labels[kubernetesPodNameLabel] = pod.Name
labels[kubernetesPodNamespaceLabel] = pod.Namespace
labels[kubernetesPodUIDLabel] = string(pod.UID)
if pod.DeletionGracePeriodSeconds != nil {
labels[kubernetesPodDeletionGracePeriodLabel] = strconv.FormatInt(*pod.DeletionGracePeriodSeconds, 10)
}
if pod.Spec.TerminationGracePeriodSeconds != nil {
labels[kubernetesPodTerminationGracePeriodLabel] = strconv.FormatInt(*pod.Spec.TerminationGracePeriodSeconds, 10)
}
labels[kubernetesContainerNameLabel] = container.Name
labels[kubernetesContainerHashLabel] = strconv.FormatUint(kubecontainer.HashContainer(container), 16)
labels[kubernetesContainerRestartCountLabel] = strconv.Itoa(restartCount)
labels[kubernetesContainerTerminationMessagePathLabel] = container.TerminationMessagePath
if container.Lifecycle != nil && container.Lifecycle.PreStop != nil {
// Using json enconding so that the PreStop handler object is readable after writing as a label
rawPreStop, err := json.Marshal(container.Lifecycle.PreStop)
if err != nil {
glog.Errorf("Unable to marshal lifecycle PreStop handler for container %q of pod %q: %v", container.Name, format.Pod(pod), err)
} else {
labels[kubernetesContainerPreStopHandlerLabel] = string(rawPreStop)
}
}
return labels
}
func (txn *dbTxn) Inc(k kv.Key, step int64) (int64, error) {
log.Debugf("Inc %q, step %d txn:%d", k, step, txn.tid)
k = kv.EncodeKey(k)
txn.markOrigin(k)
val, err := txn.UnionStore.Get(k)
if kv.IsErrNotFound(err) {
err = txn.UnionStore.Set(k, []byte(strconv.FormatInt(step, 10)))
if err != nil {
return 0, errors.Trace(err)
}
return step, nil
}
if err != nil {
return 0, errors.Trace(err)
}
intVal, err := strconv.ParseInt(string(val), 10, 0)
if err != nil {
return intVal, errors.Trace(err)
}
intVal += step
err = txn.UnionStore.Set(k, []byte(strconv.FormatInt(intVal, 10)))
if err != nil {
return 0, errors.Trace(err)
}
txn.store.compactor.OnSet(k)
return intVal, nil
}
// UploadSignedURL returns a signed URL that allows anyone holding the URL
// to upload the object at path. The signature is valid until expires.
// contenttype is a string like image/png
// path is the resource name in s3 terminalogy like images/ali.png [obviously exclusing the bucket name itself]
func (b *Bucket) UploadSignedURL(path, method, content_type string, expires time.Time) string {
expire_date := expires.Unix()
if method != "POST" {
method = "PUT"
}
stringToSign := method + "\n\n" + content_type + "\n" + strconv.FormatInt(expire_date, 10) + "\n/" + b.Name + "/" + path
fmt.Println("String to sign:\n", stringToSign)
a := b.S3.Auth
secretKey := a.SecretKey
accessId := a.AccessKey
mac := hmac.New(sha1.New, []byte(secretKey))
mac.Write([]byte(stringToSign))
macsum := mac.Sum(nil)
signature := base64.StdEncoding.EncodeToString([]byte(macsum))
signature = strings.TrimSpace(signature)
signedurl, err := url.Parse("https://" + b.Name + ".s3.amazonaws.com/")
if err != nil {
log.Println("ERROR sining url for S3 upload", err)
return ""
}
signedurl.Path += path
params := url.Values{}
params.Add("AWSAccessKeyId", accessId)
params.Add("Expires", strconv.FormatInt(expire_date, 10))
params.Add("Signature", signature)
if a.Token() != "" {
params.Add("token", a.Token())
}
signedurl.RawQuery = params.Encode()
return signedurl.String()
}
func (q Query) String() string {
s := q.Aggregator + ":"
if q.Downsample != "" {
s += q.Downsample + ":"
}
if q.Rate {
s += "rate"
if q.RateOptions.Counter {
s += "{counter"
if q.RateOptions.CounterMax != 0 {
s += ","
s += strconv.FormatInt(q.RateOptions.CounterMax, 10)
}
if q.RateOptions.ResetValue != 0 {
if q.RateOptions.CounterMax == 0 {
s += ","
}
s += ","
s += strconv.FormatInt(q.RateOptions.ResetValue, 10)
}
s += "}"
}
s += ":"
}
s += q.Metric
if len(q.Tags) > 0 {
s += q.Tags.String()
}
if len(q.Filters) > 0 {
s += q.Filters.String()
}
return s
}
func checkOut() bool {
value := strconv.FormatInt(int64(linuxSpec.Spec.Process.User.UID), 10)
job := "Uid"
resultTag := false
if checkResult(job, value) {
resultTag = true
} else {
resultTag = false
}
value = strconv.FormatInt(int64(linuxSpec.Spec.Process.User.GID), 10)
job = "Gid"
if checkResult(job, value) {
resultTag = true
} else {
resultTag = false
}
tmpValue := linuxSpec.Spec.Process.User.AdditionalGids
job = "Groups"
for _, tv := range tmpValue {
tvs := strconv.FormatInt(int64(tv), 10)
if checkResult(job, tvs) {
resultTag = true
} else {
resultTag = false
}
}
return resultTag
}
func (hp *HttpProtocol) transData(server string, transData *TransData) (err error) {
/* compose req */
uri := hp.regTopic.ReplaceAllString(hp.uri, transData.topic)
uri = hp.regMethod.ReplaceAllString(uri, transData.method)
uri = hp.regPartition.ReplaceAllString(uri, strconv.FormatInt(int64(transData.partition), 10))
uri = hp.regTransid.ReplaceAllString(uri, strconv.FormatInt(transData.transid, 10))
url := fmt.Sprintf("http://%s%s", server, uri)
req, err := http.NewRequest("POST", url, bytes.NewReader(transData.data))
if err != nil {
logger.Warning("module [%s]: fail to transData: url=%s, topic=%s, partition=%d, transid=%d, method=%s, err=%s", hp.moduleName, url, transData.topic, transData.partition, transData.transid, transData.method, err.Error())
return err
}
/* add header */
req.Header = hp.header
req.Host = hp.reqHeaderHost
/* Post */
res, err := hp.client.Do(req)
if err != nil {
logger.Warning("module [%s]: fail to transData: url=%s, topic=%s, partition=%d, transid=%d, method=%s, err=%s", hp.moduleName, url, transData.topic, transData.partition, transData.transid, transData.method, err.Error())
return err
}
defer res.Body.Close()
/* check res: 200 不重试；其他，重试 */
if res.StatusCode == http.StatusOK {
logger.Notice("module [%s]: success transData: url=%s, topic=%s, partition=%d, transid=%d, method=%s, datalen=%d, http_status_code=%d", hp.moduleName, url, transData.topic, transData.partition, transData.transid, transData.method, len(transData.data), res.StatusCode)
return nil
} else {
logger.Warning("module [%s]: fail to transData: url=%s, topic=%s, partition=%d, transid=%d, method=%s, http_status_code=%d", hp.moduleName, url, transData.topic, transData.partition, transData.transid, transData.method, res.StatusCode)
return errors.New("fail to trans")
}
return nil
}
func (i Int) floatString(verb byte, prec int) string {
switch verb {
case 'f', 'F':
str := strconv.FormatInt(int64(i), 10)
if prec > 0 {
str += "." + zeros(prec)
}
return str
case 'e', 'E':
sign := ""
if i < 0 {
sign = "-"
i = -i
}
return eFormat(verb, prec, sign, strconv.FormatInt(int64(i), 10), i.eExponent())
case 'g', 'G':
// Exponent is always positive so it's easy.
if i.eExponent() >= prec {
// Use e format.
return i.floatString(verb-2, prec-1)
}
// Use f format, but this is just an integer.
return fmt.Sprintf("%d", int64(i))
default:
Errorf("can't handle verb %c for int", verb)
}
return ""
}
//checkResults checks the results between
func checkResults() string {
for metric, expected := range expectedValues {
switch m := metric.(type) {
case *metrics.Counter:
val, ok := expected.(uint64)
if !ok {
return "unexpected type"
}
if m.Get() != val {
return ("unexpected value - got: " +
strconv.FormatInt(int64(m.Get()), 10) + " but wanted " + strconv.FormatInt(int64(val), 10))
}
case *metrics.Gauge:
val, ok := expected.(float64)
if !ok {
return "unexpected type"
}
if m.Get() != val {
return ("unexpected value - got: " +
strconv.FormatFloat(float64(m.Get()), 'f', 5, 64) + " but wanted " +
strconv.FormatFloat(float64(val), 'f', 5, 64))
}
}
}
return ""
}
// ToString converts a interface to a string.
func ToString(value interface{}) (string, error) {
switch v := value.(type) {
case bool:
if v {
return "1", nil
}
return "0", nil
case int:
return strconv.FormatInt(int64(v), 10), nil
case int64:
return strconv.FormatInt(int64(v), 10), nil
case uint64:
return strconv.FormatUint(uint64(v), 10), nil
case float32:
return strconv.FormatFloat(float64(v), 'f', -1, 32), nil
case float64:
return strconv.FormatFloat(float64(v), 'f', -1, 64), nil
case string:
return v, nil
case []byte:
return string(v), nil
case mysql.Time:
return v.String(), nil
case mysql.Duration:
return v.String(), nil
case mysql.Decimal:
return v.String(), nil
case mysql.Hex:
return v.ToString(), nil
case mysql.Bit:
return v.ToString(), nil
default:
return "", errors.Errorf("cannot convert %v(type %T) to string", value, value)
}
}
func (dir *Directory) save(i int64, l [][]string) error {
b := new(bytes.Buffer)
w := csv.NewWriter(b)
w.WriteAll(l)
w.Flush()
// done!
part := strconv.FormatInt(i, 10) + "."
p, e := LoadDPs(dir.R, part)
if e != nil {
p = new(DirPage)
e = nil
}
p.Version = (p.Version + 1) % 8
e = SaveDPs(dir.R, p, part)
if e != nil {
return e
}
pver := part + strconv.FormatInt(p.Version, 10)
f, e := dir.R.Create(pver)
if e != nil {
return e
}
defer f.Close()
e = f.Truncate(int64(b.Len()))
if e != nil {
return e
}
_, e = f.WriteAt(b.Bytes(), 0)
return e
}
// Coerce types (string,int,int64, float, []byte) into String type
func CoerceString(v interface{}) (string, error) {
switch val := v.(type) {
case string:
if val == "null" || val == "NULL" {
return "", nil
}
return val, nil
case int:
return strconv.Itoa(val), nil
case int32:
return strconv.FormatInt(int64(val), 10), nil
case int64:
return strconv.FormatInt(val, 10), nil
case uint32:
return strconv.FormatUint(uint64(val), 10), nil
case uint64:
return strconv.FormatUint(val, 10), nil
case float32:
return strconv.FormatFloat(float64(val), 'f', -1, 32), nil
case float64:
return strconv.FormatFloat(val, 'f', -1, 64), nil
case []byte:
if string(val) == "null" || string(val) == "NULL" {
return "", nil
}
return string(val), nil
case json.RawMessage:
if string(val) == "null" || string(val) == "NULL" {
return "", nil
}
return string(val), nil
}
return "", fmt.Errorf("Could not coerce to string: %v", v)
}
// SignedURLWithMethod returns a signed URL that allows anyone holding the URL
// to either retrieve the object at path or make a HEAD request against it. The signature is valid until expires.
func (b *Bucket) SignedURLWithMethod(method, path string, expires time.Time, params url.Values, headers http.Header) string {
var uv = url.Values{}
if params != nil {
uv = params
}
if b.S3.Signature == aws.V2Signature {
uv.Set("Expires", strconv.FormatInt(expires.Unix(), 10))
} else {
uv.Set("X-Amz-Expires", strconv.FormatInt(expires.Unix()-time.Now().Unix(), 10))
}
req := &request{
method: method,
bucket: b.Name,
path: path,
params: uv,
headers: headers,
}
err := b.S3.prepare(req)
if err != nil {
panic(err)
}
u, err := req.url()
if err != nil {
panic(err)
}
if b.S3.Auth.Token() != "" && b.S3.Signature == aws.V2Signature {
return u.String() + "&x-amz-security-token=" + url.QueryEscape(req.headers["X-Amz-Security-Token"][0])
} else {
return u.String()
}
}
// Create a new volume.
func (ec2 *EC2Conn) CreateVolume(options *CreateVolume) (resp *CreateVolumeResp, err error) {
params := makeParams("CreateVolume")
params["AvailabilityZone"] = options.AvailZone
if options.Size > 0 {
params["Size"] = strconv.FormatInt(options.Size, 10)
}
if options.SnapshotId != "" {
params["SnapshotId"] = options.SnapshotId
}
if options.VolumeType != "" {
params["VolumeType"] = options.VolumeType
}
if options.IOPS > 0 {
params["Iops"] = strconv.FormatInt(options.IOPS, 10)
}
resp = &CreateVolumeResp{}
err = ec2.query(params, resp)
if err != nil {
return nil, err
}
return
}
func TestGetSpot(t *testing.T) {
opt := aetest.Options{AppID: "t2jp-2015", StronglyConsistentDatastore: true}
inst, err := aetest.NewInstance(&opt)
defer inst.Close()
input, err := json.Marshal(Spot{SpotName: "foo", Body: "bar"})
req, err := inst.NewRequest("POST", "/edit/v1/spots", bytes.NewBuffer(input))
if err != nil {
t.Fatalf("Failed to create req: %v", err)
}
loginUser := user.User{Email: "*****@*****.**", Admin: false, ID: "111111"}
aetest.Login(&loginUser, req)
// ctx := appengine.NewContext(req)
res := httptest.NewRecorder()
c := web.C{}
spotCreateHandler(c, res, req)
if res.Code != http.StatusCreated {
t.Fatalf("Fail to request spots create, status code: %v", res.Code)
}
var getResponse GetResponse
err = json.NewDecoder(res.Body).Decode(&getResponse)
spotCode := getResponse.Item.SpotCode
t.Logf("spot code: %v", strconv.FormatInt(spotCode, 10))
getReq, err := inst.NewRequest("GET", "/edit/v1/spots/"+strconv.FormatInt(spotCode, 10), nil)
if err != nil {
t.Fatalf("Failed to create req: %v", err)
}
getRes := httptest.NewRecorder()
getC := web.C{URLParams: map[string]string{"spotCode": strconv.FormatInt(spotCode, 10)}}
spotGetHandler(getC, getRes, getReq)
if getRes.Code != http.StatusOK {
t.Fatalf("Fail to request spot get, status code: %v", getRes.Code)
}
}
func handleLog(client *client.Client, namespace, podID string, logOptions *api.PodLogOptions, out io.Writer) error {
// TODO: transform this into a PodLogOptions call
req := client.RESTClient.Get().
Namespace(namespace).
Name(podID).
Resource("pods").
SubResource("log").
Param("follow", strconv.FormatBool(logOptions.Follow)).
Param("container", logOptions.Container).
Param("previous", strconv.FormatBool(logOptions.Previous)).
Param("timestamps", strconv.FormatBool(logOptions.Timestamps))
if logOptions.SinceSeconds != nil {
req.Param("sinceSeconds", strconv.FormatInt(*logOptions.SinceSeconds, 10))
}
if logOptions.SinceTime != nil {
req.Param("sinceTime", logOptions.SinceTime.Format(time.RFC3339))
}
if logOptions.LimitBytes != nil {
req.Param("limitBytes", strconv.FormatInt(*logOptions.LimitBytes, 10))
}
if logOptions.TailLines != nil {
req.Param("tailLines", strconv.FormatInt(*logOptions.TailLines, 10))
}
readCloser, err := req.Stream()
if err != nil {
return err
}
defer readCloser.Close()
_, err = io.Copy(out, readCloser)
return err
}
func (p *UpdateStoragePoolParams) toURLValues() url.Values {
u := url.Values{}
if p.p == nil {
return u
}
if v, found := p.p["capacitybytes"]; found {
vv := strconv.FormatInt(v.(int64), 10)
u.Set("capacitybytes", vv)
}
if v, found := p.p["capacityiops"]; found {
vv := strconv.FormatInt(v.(int64), 10)
u.Set("capacityiops", vv)
}
if v, found := p.p["enabled"]; found {
vv := strconv.FormatBool(v.(bool))
u.Set("enabled", vv)
}
if v, found := p.p["id"]; found {
u.Set("id", v.(string))
}
if v, found := p.p["tags"]; found {
vv := strings.Join(v.([]string), ",")
u.Set("tags", vv)
}
return u
}
func (k *Kraken) GetTradesHistory(tradeType string, showRelatedTrades bool, start, end, offset int64) {
values := url.Values{}
if len(tradeType) > 0 {
values.Set("aclass", tradeType)
}
if showRelatedTrades {
values.Set("trades", "true")
}
if start != 0 {
values.Set("start", strconv.FormatInt(start, 10))
}
if end != 0 {
values.Set("end", strconv.FormatInt(end, 10))
}
if offset != 0 {
values.Set("offset", strconv.FormatInt(offset, 10))
}
result, err := k.SendAuthenticatedHTTPRequest(KRAKEN_TRADES_HISTORY, values)
if err != nil {
log.Println(err)
return
}
log.Println(result)
}
func prepareBlockDevices(params map[string]string, blockDevs []BlockDeviceMapping) {
for i, b := range blockDevs {
n := strconv.Itoa(i + 1)
prefix := "BlockDeviceMapping." + n
if b.DeviceName != "" {
params[prefix+".DeviceName"] = b.DeviceName
}
if b.VirtualName != "" {
params[prefix+".VirtualName"] = b.VirtualName
}
if b.SnapshotId != "" {
params[prefix+".Ebs.SnapshotId"] = b.SnapshotId
}
if b.VolumeType != "" {
params[prefix+".Ebs.VolumeType"] = b.VolumeType
}
if b.VolumeSize > 0 {
params[prefix+".Ebs.VolumeSize"] = strconv.FormatInt(b.VolumeSize, 10)
}
if b.IOPS > 0 {
params[prefix+".Ebs.Iops"] = strconv.FormatInt(b.IOPS, 10)
}
if b.DeleteOnTermination {
params[prefix+".Ebs.DeleteOnTermination"] = "true"
}
}
}
// PutScheduledUpdateGroupAction creates or updates a scheduled scaling action for an
// AutoScaling group. Scheduled actions can be made up to thirty days in advance. When updating
// a scheduled scaling action, if you leave a parameter unspecified, the corresponding value
// remains unchanged in the affected AutoScaling group.
//
// Auto Scaling supports the date and time expressed in "YYYY-MM-DDThh:mm:ssZ" format in UTC/GMT
// only.
func (as *AutoScaling) PutScheduledUpdateGroupAction(rp PutScheduledActionRequestParams) (
resp *SimpleResp, err error) {
resp = &SimpleResp{}
params := makeParams("PutScheduledUpdateGroupAction")
params["AutoScalingGroupName"] = rp.AutoScalingGroupName
params["ScheduledActionName"] = rp.ScheduledActionName
if len(rp.EndTime) > 0 {
params["EndTime"] = rp.EndTime
}
if len(rp.StartTime) > 0 {
params["StartTime"] = rp.StartTime
}
if rp.MaxSize > 0 {
params["MaxSize"] = strconv.FormatInt(rp.MaxSize, 10)
}
if rp.MinSize > 0 {
params["MinSize"] = strconv.FormatInt(rp.MinSize, 10)
}
if len(rp.Recurrence) > 0 {
params["Recurrence"] = rp.Recurrence
}
err = as.query(params, resp)
if err != nil {
return nil, err
}
return resp, nil
}
func (daemon *Daemon) initCgroupsPath(path string) error {
if path == "/" || path == "." {
return nil
}
daemon.initCgroupsPath(filepath.Dir(path))
_, root, err := cgroups.FindCgroupMountpointAndRoot("cpu")
if err != nil {
return err
}
path = filepath.Join(root, path)
sysinfo := sysinfo.New(false)
if err := os.MkdirAll(path, 0755); err != nil && !os.IsExist(err) {
return err
}
if sysinfo.CPURealtimePeriod && daemon.configStore.CPURealtimePeriod != 0 {
if err := ioutil.WriteFile(filepath.Join(path, "cpu.rt_period_us"), []byte(strconv.FormatInt(daemon.configStore.CPURealtimePeriod, 10)), 0700); err != nil {
return err
}
}
if sysinfo.CPURealtimeRuntime && daemon.configStore.CPURealtimeRuntime != 0 {
if err := ioutil.WriteFile(filepath.Join(path, "cpu.rt_runtime_us"), []byte(strconv.FormatInt(daemon.configStore.CPURealtimeRuntime, 10)), 0700); err != nil {
return err
}
}
return nil
}
//登录
func (this *AccountController) Login() {
if this.userid > 0 {
this.Redirect("/admin", 302)
}
if this.GetString("dosubmit") == "yes" {
account := strings.TrimSpace(this.GetString("account"))
password := strings.TrimSpace(this.GetString("password"))
remember := this.GetString("remember")
if account != "" && password != "" {
var user models.User
user.Name = account
if user.Read("name") != nil || user.Password != util.Md5([]byte(password)) {
this.Data["errmsg"] = "帐号或密码错误"
} else if user.Active == 0 {
this.Data["errmsg"] = "该帐号未激活"
} else {
user.LoginCount += 1
user.LastIp = this.getClientIp()
user.LastLogin = this.getTime()
user.Update()
authkey := util.Md5([]byte(this.getClientIp() + "|" + user.Password))
if remember == "yes" {
this.Ctx.SetCookie("auth", strconv.FormatInt(user.Id, 10)+"|"+authkey, 7*86400)
} else {
this.Ctx.SetCookie("auth", strconv.FormatInt(user.Id, 10)+"|"+authkey)
}
this.Redirect("/admin", 302)
}
}
}
this.TplNames = this.moduleName + "/account/login.html"
}
func (raw *rawCgroup) setupMemory(c *Cgroup, pid int) (err error) {
dir, err := raw.join("memory", pid)
// only return an error for memory if it was not specified
if err != nil && (c.Memory != 0 || c.MemorySwap != 0) {
return err
}
defer func() {
if err != nil {
os.RemoveAll(dir)
}
}()
if c.Memory != 0 || c.MemorySwap != 0 {
if c.Memory != 0 {
if err := writeFile(dir, "memory.limit_in_bytes", strconv.FormatInt(c.Memory, 10)); err != nil {
return err
}
if err := writeFile(dir, "memory.soft_limit_in_bytes", strconv.FormatInt(c.Memory, 10)); err != nil {
return err
}
}
// By default, MemorySwap is set to twice the size of RAM.
// If you want to omit MemorySwap, set it to `-1'.
if c.MemorySwap != -1 {
if err := writeFile(dir, "memory.memsw.limit_in_bytes", strconv.FormatInt(c.Memory*2, 10)); err != nil {
return err
}
}
}
return nil
}
func addBlockDeviceParams(params map[string]string, blockdevices []BlockDeviceMapping) {
for i, k := range blockdevices {
// Fixup index since Amazon counts these from 1
prefix := "BlockDeviceMapping." + strconv.Itoa(i+1) + "."
if k.DeviceName != "" {
params[prefix+"DeviceName"] = k.DeviceName
}
if k.VirtualName != "" {
params[prefix+"VirtualName"] = k.VirtualName
}
if k.SnapshotId != "" {
params[prefix+"Ebs.SnapshotId"] = k.SnapshotId
}
if k.VolumeType != "" {
params[prefix+"Ebs.VolumeType"] = k.VolumeType
}
if k.IOPS != 0 {
params[prefix+"Ebs.Iops"] = strconv.FormatInt(k.IOPS, 10)
}
if k.VolumeSize != 0 {
params[prefix+"Ebs.VolumeSize"] = strconv.FormatInt(k.VolumeSize, 10)
}
if k.DeleteOnTermination {
params[prefix+"Ebs.DeleteOnTermination"] = "true"
}
}
}
// Route routes an update packet to the correct server.
func (r *Router) Route(cancelSignal <-chan bool, uaid, chid string, version int64, sentAt time.Time, logID string) (err error) {
startTime := time.Now()
locator := r.Locator()
if locator == nil {
if r.logger.ShouldLog(ERROR) {
r.logger.Error("router", "No discovery service set; unable to route message",
LogFields{"rid": logID, "uaid": uaid, "chid": chid})
}
r.metrics.Increment("router.broadcast.error")
return ErrNoLocator
}
segment := capn.NewBuffer(nil)
routable := NewRootRoutable(segment)
routable.SetChannelID(chid)
routable.SetVersion(version)
routable.SetTime(sentAt.UnixNano())
contacts, err := locator.Contacts(uaid)
if err != nil {
if r.logger.ShouldLog(CRITICAL) {
r.logger.Critical("router", "Could not query discovery service for contacts",
LogFields{"rid": logID, "error": err.Error()})
}
r.metrics.Increment("router.broadcast.error")
return err
}
if r.logger.ShouldLog(DEBUG) {
r.logger.Debug("router", "Fetched contact list from discovery service",
LogFields{"rid": logID, "servers": strings.Join(contacts, ", ")})
}
if r.logger.ShouldLog(INFO) {
r.logger.Info("router", "Sending push...", LogFields{
"rid": logID,
"uaid": uaid,
"chid": chid,
"version": strconv.FormatInt(version, 10),
"time": strconv.FormatInt(sentAt.UnixNano(), 10)})
}
ok, err := r.notifyAll(cancelSignal, contacts, uaid, segment, logID)
endTime := time.Now()
if err != nil {
if r.logger.ShouldLog(WARNING) {
r.logger.Warn("router", "Could not post to server",
LogFields{"rid": logID, "error": err.Error()})
}
r.metrics.Increment("router.broadcast.error")
return err
}
var counterName, timerName string
if ok {
counterName = "router.broadcast.hit"
timerName = "updates.routed.hits"
} else {
counterName = "router.broadcast.miss"
timerName = "updates.routed.misses"
}
r.metrics.Increment(counterName)
r.metrics.Timer(timerName, endTime.Sub(sentAt))
r.metrics.Timer("router.handled", endTime.Sub(startTime))
return nil
}
func joinMemory(c *configs.Cgroup, pid int) error {
path, err := getSubsystemPath(c, "memory")
if err != nil && !cgroups.IsNotFound(err) {
return err
}
// -1 disables memoryswap
if c.MemorySwap > 0 {
err = writeFile(path, "memory.memsw.limit_in_bytes", strconv.FormatInt(c.MemorySwap, 10))
if err != nil {
return err
}
}
if c.OomKillDisable {
if err := writeFile(path, "memory.oom_control", "1"); err != nil {
return err
}
}
if c.MemorySwappiness >= 0 && c.MemorySwappiness <= 100 {
err = writeFile(path, "memory.swappiness", strconv.FormatInt(c.MemorySwappiness, 10))
if err != nil {
return err
}
} else if c.MemorySwappiness == -1 {
return nil
} else {
return fmt.Errorf("invalid value:%d. valid memory swappiness range is 0-100", c.MemorySwappiness)
}
return nil
}
func Format_size(size int64) string {
//size = 1073741824
if size >= 1099511627776 {
if size%1099511627776 == 0 {
return strconv.FormatInt(size/1099511627776, 10) + " T"
} else {
return strconv.FormatFloat(float64(size)/float64(1099511627776), 'f', 2, 64) + " T"
}
} else if size >= 1073741824 {
if size%1073741824 == 0 {
return strconv.FormatInt(size/1073741824, 10) + " G"
} else {
return strconv.FormatFloat(float64(size)/float64(1073741824), 'f', 2, 64) + " G"
}
} else if size >= 1048576 {
if size%1048576 == 0 {
return strconv.FormatInt(size/1048576, 10) + " M"
} else {
return strconv.FormatFloat(float64(size)/float64(1048576), 'f', 2, 64) + " M"
}
} else if size >= 1024 {
if size%1024 == 0 {
return strconv.FormatInt(size/1024, 10) + " K"
} else {
return strconv.FormatFloat(float64(size)/float64(1024), 'f', 2, 64) + " K"
}
} else {
return strconv.FormatInt(size, 10) + " B"
}
}