func (this *Topics) addTopic(zkcluster *zk.ZkCluster, topic string, replicas,
partitions int) error {
this.Ui.Info(fmt.Sprintf("creating kafka topic: %s", topic))
ts := sla.DefaultSla()
ts.Partitions = partitions
ts.Replicas = replicas
lines, err := zkcluster.AddTopic(topic, ts)
if err != nil {
return err
}
for _, l := range lines {
this.Ui.Output(color.Yellow(l))
}
if this.ipInNumber {
this.Ui.Output(fmt.Sprintf("\tzookeeper.connect: %s", zkcluster.ZkConnectAddr()))
this.Ui.Output(fmt.Sprintf("\t broker.list: %s",
strings.Join(zkcluster.BrokerList(), ",")))
} else {
this.Ui.Output(fmt.Sprintf("\tzookeeper.connect: %s", zkcluster.NamedZkConnectAddr()))
this.Ui.Output(fmt.Sprintf("\t broker.list: %s",
strings.Join(zkcluster.NamedBrokerList(), ",")))
}
return nil
}
func (this *Topics) configTopic(zkcluster *zk.ZkCluster, topic string, retentionInMinute int) {
/*
val SegmentBytesProp = "segment.bytes"
val SegmentMsProp = "segment.ms"
val SegmentIndexBytesProp = "segment.index.bytes"
val FlushMessagesProp = "flush.messages"
val FlushMsProp = "flush.ms"
val RetentionBytesProp = "retention.bytes"
val RententionMsProp = "retention.ms"
val MaxMessageBytesProp = "max.message.bytes"
val IndexIntervalBytesProp = "index.interval.bytes"
val DeleteRetentionMsProp = "delete.retention.ms"
val FileDeleteDelayMsProp = "file.delete.delay.ms"
val MinCleanableDirtyRatioProp = "min.cleanable.dirty.ratio"
val CleanupPolicyProp = "cleanup.policy"
*/
// ./bin/kafka-topics.sh --zookeeper localhost:2181/kafka --alter --topic foobar --config max.message.bytes=10000101
// zk: {"version":1,"config":{"index.interval.bytes":"10000101","max.message.bytes":"10000101"}}
if retentionInMinute < 10 {
panic("less than 10 minutes?")
}
ts := sla.DefaultSla()
ts.RetentionHours = float64(retentionInMinute) / 60
output, err := zkcluster.AlterTopic(topic, ts)
if err != nil {
this.Ui.Error(fmt.Sprintf("%+v: %v", ts, err))
os.Exit(1)
}
path := zkcluster.GetTopicConfigPath(topic)
this.Ui.Info(path)
for _, line := range output {
this.Ui.Output(line)
}
}
// @rest PUT /v1/topics/:appid/:topic/:ver?partitions=1&retention.hours=72&retention.bytes=-1
func (this *manServer) alterTopicHandler(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
topic := params.ByName(UrlParamTopic)
if !manager.Default.ValidateTopicName(topic) {
log.Warn("illegal topic: %s", topic)
writeBadRequest(w, "illegal topic")
return
}
realIp := getHttpRemoteIp(r)
if !this.throttleAddTopic.Pour(realIp, 1) {
writeQuotaExceeded(w)
return
}
hisAppid := params.ByName(UrlParamAppid)
appid := r.Header.Get(HttpHeaderAppid)
pubkey := r.Header.Get(HttpHeaderPubkey)
ver := params.ByName(UrlParamVersion)
if !manager.Default.AuthAdmin(appid, pubkey) {
log.Warn("suspicous alter topic from %s(%s) {appid:%s pubkey:%s topic:%s ver:%s}",
r.RemoteAddr, realIp, appid, pubkey, topic, ver)
writeAuthFailure(w, manager.ErrAuthenticationFail)
return
}
cluster, found := manager.Default.LookupCluster(hisAppid)
if !found {
log.Error("alter topic[%s] %s(%s) {app:%s topic:%s ver:%s} invalid appid",
appid, r.RemoteAddr, realIp, hisAppid, topic, ver)
writeBadRequest(w, "invalid appid")
return
}
zkcluster := meta.Default.ZkCluster(cluster)
if zkcluster == nil {
log.Error("alter topic from %s(%s) {appid:%s pubkey:%s cluster:%s topic:%s ver:%s} undefined cluster",
r.RemoteAddr, realIp, appid, pubkey, cluster, topic, ver)
writeBadRequest(w, "undefined cluster")
return
}
info := zkcluster.RegisteredInfo()
if !info.Public {
log.Warn("app[%s] alter topic:%s in non-public cluster: %+v", hisAppid, topic, params)
writeBadRequest(w, "invalid cluster")
return
}
ts := sla.DefaultSla()
query := r.URL.Query()
if partitionsArg := query.Get(sla.SlaKeyPartitions); partitionsArg != "" {
ts.Partitions, _ = strconv.Atoi(partitionsArg)
}
if retentionBytes := query.Get(sla.SlaKeyRetentionBytes); retentionBytes != "" {
ts.RetentionBytes, _ = strconv.Atoi(retentionBytes)
}
ts.ParseRetentionHours(query.Get(sla.SlaKeyRetentionHours))
// validate the sla
if err := ts.Validate(); err != nil {
log.Error("app[%s] alter topic:%s %s: %+v", hisAppid, topic, query.Encode(), err)
writeBadRequest(w, err.Error())
return
}
log.Info("app[%s] from %s(%s) alter topic: {appid:%s cluster:%s topic:%s ver:%s query:%s}",
appid, r.RemoteAddr, realIp, hisAppid, cluster, topic, ver, query.Encode())
rawTopic := manager.Default.KafkaTopic(hisAppid, topic, ver)
alterConfig := ts.DumpForAlterTopic()
if len(alterConfig) == 0 {
log.Warn("app[%s] from %s(%s) alter topic: {appid:%s cluster:%s topic:%s ver:%s query:%s} nothing updated",
appid, r.RemoteAddr, realIp, hisAppid, cluster, topic, ver, query.Encode())
writeBadRequest(w, "nothing updated")
return
}
lines, err := zkcluster.AlterTopic(rawTopic, ts)
if err != nil {
log.Error("app[%s] from %s(%s) alter topic: {appid:%s cluster:%s topic:%s ver:%s query:%s} %v",
appid, r.RemoteAddr, realIp, hisAppid, cluster, topic, ver, query.Encode(), err)
writeServerError(w, err.Error())
return
}
for _, l := range lines {
log.Trace("app[%s] alter topic[%s] in cluster %s: %s", appid, rawTopic, cluster, l)
}
w.Write(ResponseOk)
}
