func (es *ElasticSearch) Conn() error {
client, err := elastic.NewClient(
elastic.SetURL(es.uri),
elastic.SetSniff(false),
elastic.SetHealthcheckInterval(10*time.Second),
elastic.SetMaxRetries(5))
if err != nil {
// Handle error
return err
}
exists, err := client.IndexExists(es.index).Do()
if err != nil {
// Handle error
return err
}
if !exists {
// Create a new index.
createIndex, err := client.CreateIndex(es.index).Do()
if err != nil {
// Handle error
return err
}
if !createIndex.Acknowledged {
// Not acknowledged
}
}
es.client = client
return nil
}
// InitClient sets up the elastic client. If the client has already been
// initalized it is a noop
func (e LogstashElasticHosts) InitClient() error {
if lsClient == nil {
var err error
lsClient, err = elastic.NewClient(elastic.SetURL(e...), elastic.SetMaxRetries(10))
if err != nil {
return err
}
}
return nil
}
func TestCreateElasticSearchConfig(t *testing.T) {
url, err := url.Parse("?nodes=https://foo.com:20468&nodes=https://bar.com:20468&esUserName=test&esUserSecret=password&maxRetries=10&startupHealthcheckTimeout=30&sniff=false&healthCheck=false")
if err != nil {
t.Fatalf("Error when parsing URL: %s", err.Error())
}
config, err := CreateElasticSearchConfig(url)
if err != nil {
t.Fatalf("Error when creating config: %s", err.Error())
}
expectedClient, err := elastic.NewClient(
elastic.SetURL("https://foo.com:20468", "https://bar.com:20468"),
elastic.SetBasicAuth("test", "password"),
elastic.SetMaxRetries(10),
elastic.SetHealthcheckTimeoutStartup(30*time.Second),
elastic.SetSniff(false), elastic.SetHealthcheck(false))
if err != nil {
t.Fatalf("Error when creating client: %s", err.Error())
}
actualClientRefl := reflect.ValueOf(config.EsClient).Elem()
expectedClientRefl := reflect.ValueOf(expectedClient).Elem()
if actualClientRefl.FieldByName("basicAuthUsername").String() != expectedClientRefl.FieldByName("basicAuthUsername").String() {
t.Fatalf("basicAuthUsername is not equal")
}
if actualClientRefl.FieldByName("basicAuthUsername").String() != expectedClientRefl.FieldByName("basicAuthUsername").String() {
t.Fatalf("basicAuthUsername is not equal")
}
if actualClientRefl.FieldByName("maxRetries").Int() != expectedClientRefl.FieldByName("maxRetries").Int() {
t.Fatalf("maxRetries is not equal")
}
if actualClientRefl.FieldByName("healthcheckTimeoutStartup").Int() != expectedClientRefl.FieldByName("healthcheckTimeoutStartup").Int() {
t.Fatalf("healthcheckTimeoutStartup is not equal")
}
if actualClientRefl.FieldByName("snifferEnabled").Bool() != expectedClientRefl.FieldByName("snifferEnabled").Bool() {
t.Fatalf("snifferEnabled is not equal")
}
if actualClientRefl.FieldByName("healthcheckEnabled").Bool() != expectedClientRefl.FieldByName("healthcheckEnabled").Bool() {
t.Fatalf("healthcheckEnabled is not equal")
}
}
func ExampleClient_NewClient_manyOptions() {
// Obtain a client for an Elasticsearch cluster of two nodes,
// running on 10.0.1.1 and 10.0.1.2. Do not run the sniffer.
// Set the healthcheck interval to 10s. When requests fail,
// retry 5 times. Print error messages to os.Stderr and informational
// messages to os.Stdout.
client, err := elastic.NewClient(
elastic.SetURL("http://10.0.1.1:9200", "http://10.0.1.2:9200"),
elastic.SetSniff(false),
elastic.SetHealthcheckInterval(10*time.Second),
elastic.SetMaxRetries(5),
elastic.SetErrorLog(log.New(os.Stderr, "ELASTIC ", log.LstdFlags)),
elastic.SetInfoLog(log.New(os.Stdout, "", log.LstdFlags)))
if err != nil {
// Handle error
panic(err)
}
_ = client
}
/**
*音乐查询接口1a
*/
func MusicHandler(w http.ResponseWriter, r *http.Request) {
client, err := elastic.NewClient(elastic.SetURL(urles), elastic.SetMaxRetries(10))
if err != nil {
fmt.Fprint(w, "ES联接有问题", err)
} else {
jsdata := r.FormValue("jsondata")
var conds Conditions
err := json.Unmarshal([]byte(jsdata), &conds)
if err != nil {
fmt.Println("格式存在问题")
fmt.Fprint(w, "格式存在问题")
} else if len(conds.UserKey) <= 0 {
fmt.Fprint(w, "请出示你的Key")
} else {
fmt.Println(conds.ArtisName, conds.Special, conds.Name)
fmt.Fprint(w, getData(*client, conds))
}
}
}
func (t *TestCase) setup() error {
var errorlogger *log.Logger
if t.errorlogfile != "" {
f, err := os.OpenFile(t.errorlogfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0664)
if err != nil {
return err
}
errorlogger = log.New(f, "", log.Ltime|log.Lmicroseconds|log.Lshortfile)
}
var infologger *log.Logger
if t.infologfile != "" {
f, err := os.OpenFile(t.infologfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0664)
if err != nil {
return err
}
infologger = log.New(f, "", log.LstdFlags)
}
// Trace request and response details like this
var tracelogger *log.Logger
if t.tracelogfile != "" {
f, err := os.OpenFile(t.tracelogfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0664)
if err != nil {
return err
}
tracelogger = log.New(f, "", log.LstdFlags)
}
client, err := elastic.NewClient(
elastic.SetURL(t.nodes...),
elastic.SetErrorLog(errorlogger),
elastic.SetInfoLog(infologger),
elastic.SetTraceLog(tracelogger),
elastic.SetMaxRetries(t.maxRetries),
elastic.SetSniff(t.sniff),
elastic.SetSnifferInterval(t.snifferInterval),
elastic.SetHealthcheck(t.healthcheck),
elastic.SetHealthcheckInterval(t.healthcheckInterval))
if err != nil {
// Handle error
return err
}
t.client = client
// Use the IndexExists service to check if a specified index exists.
exists, err := t.client.IndexExists(t.index).Do()
if err != nil {
return err
}
if exists {
deleteIndex, err := t.client.DeleteIndex(t.index).Do()
if err != nil {
return err
}
if !deleteIndex.Acknowledged {
return errors.New("delete index not acknowledged")
}
}
// Create a new index.
createIndex, err := t.client.CreateIndex(t.index).Do()
if err != nil {
return err
}
if !createIndex.Acknowledged {
return errors.New("create index not acknowledged")
}
// Index a tweet (using JSON serialization)
tweet1 := Tweet{User: "******", Message: "Take Five", Retweets: 0}
_, err = t.client.Index().
Index(t.index).
Type("tweet").
Id("1").
BodyJson(tweet1).
Do()
if err != nil {
return err
}
// Index a second tweet (by string)
tweet2 := `{"user" : "olivere", "message" : "It's a Raggy Waltz"}`
_, err = t.client.Index().
Index(t.index).
Type("tweet").
Id("2").
BodyString(tweet2).
Do()
if err != nil {
return err
}
// Flush to make sure the documents got written.
_, err = t.client.Flush().Index(t.index).Do()
if err != nil {
return err
}
return nil
}
// CreateElasticSearchConfig creates an ElasticSearch configuration struct
// which contains an ElasticSearch client for later use
func CreateElasticSearchConfig(uri *url.URL) (*ElasticSearchConfig, error) {
var esConfig ElasticSearchConfig
opts, err := url.ParseQuery(uri.RawQuery)
if err != nil {
return nil, fmt.Errorf("failed to parser url's query string: %s", err)
}
// set the index for es,the default value is "heapster"
esConfig.Index = ESIndex
if len(opts["index"]) > 0 {
esConfig.Index = opts["index"][0]
}
// Set the URL endpoints of the ES's nodes. Notice that when sniffing is
// enabled, these URLs are used to initially sniff the cluster on startup.
if len(opts["nodes"]) < 1 {
return nil, fmt.Errorf("There is no node assigned for connecting ES cluster")
}
startupFns := []elastic.ClientOptionFunc{elastic.SetURL(opts["nodes"]...)}
// If the ES cluster needs authentication, the username and secret
// should be set in sink config.Else, set the Authenticate flag to false
if len(opts["esUserName"]) > 0 && len(opts["esUserSecret"]) > 0 {
startupFns = append(startupFns, elastic.SetBasicAuth(opts["esUserName"][0], opts["esUserSecret"][0]))
}
if len(opts["maxRetries"]) > 0 {
maxRetries, err := strconv.Atoi(opts["maxRetries"][0])
if err != nil {
return nil, fmt.Errorf("Failed to parse URL's maxRetries value into an int")
}
startupFns = append(startupFns, elastic.SetMaxRetries(maxRetries))
}
if len(opts["healthCheck"]) > 0 {
healthCheck, err := strconv.ParseBool(opts["healthCheck"][0])
if err != nil {
return nil, fmt.Errorf("Failed to parse URL's healthCheck value into a bool")
}
startupFns = append(startupFns, elastic.SetHealthcheck(healthCheck))
}
if len(opts["sniff"]) > 0 {
sniff, err := strconv.ParseBool(opts["sniff"][0])
if err != nil {
return nil, fmt.Errorf("Failed to parse URL's sniff value into a bool")
}
startupFns = append(startupFns, elastic.SetSniff(sniff))
}
if len(opts["startupHealthcheckTimeout"]) > 0 {
timeout, err := time.ParseDuration(opts["startupHealthcheckTimeout"][0] + "s")
if err != nil {
return nil, fmt.Errorf("Failed to parse URL's startupHealthcheckTimeout: %s", err.Error())
}
startupFns = append(startupFns, elastic.SetHealthcheckTimeoutStartup(timeout))
}
esConfig.EsClient, err = elastic.NewClient(startupFns...)
if err != nil {
return nil, fmt.Errorf("failed to create ElasticSearch client: %v", err)
}
glog.V(2).Infof("elasticsearch sink configure successfully")
return &esConfig, nil
}