Elasticsearch (Search Service)

const elasticsearch = require('elasticsearch');
const config = require("platformsh-config").config();

exports.usageExample = async function() {

    const credentials = config.credentials('elasticsearch');

    var client = new elasticsearch.Client({
        host: `${credentials.host}:${credentials.port}`,
    });


    let index = 'my_index';
    let type = 'People';

    // Index a few document.
    let names = ['Ada Lovelace', 'Alonzo Church', 'Barbara Liskov'];

    let message = {
        refresh: "wait_for",
        body: []
    };
    names.forEach((name) => {
        message.body.push({index: {_index: index, _type: type}});
        message.body.push({name: name});
    });
    await client.bulk(message);

    // Search for documents.
    const response = await client.search({
        index: index,
        q: 'name:Barbara Liskov'
    });

    let output = '';

    if(response.hits.total > 0) {
        output += `<table>
        <thead>
        <tr><th>ID</th><th>Name</th></tr>
        </thead>
        <tbody>`;
        response.hits.hits.forEach((record) => {
            output += `<tr><td>${record._id}</td><td>${record._source.name}</td></tr>\n`;
        });
        output += "</tbody>\n</table>\n";
    }

    // Clean up after ourselves.
    response.hits.hits.forEach((record) => {
        client.delete({
            index: index,
            type: type,
            id: record._id,
        });
    });

    return output;
};

import elasticsearch
from platformshconfig import Config

def usage_example():

    # Create a new Config object to ease reading the Platform.sh environment variables.
    # You can alternatively use os.environ yourself.
    config = Config()

    # Get the credentials to connect to the Elasticsearch service.
    credentials = config.credentials('elasticsearch')

    try:
        # The Elasticsearch library lets you connect to multiple hosts.
        # On Platform.sh Standard there is only a single host so just register that.
        hosts = {
            "scheme": credentials['scheme'],
            "host": credentials['host'],
            "port": credentials['port']
        }

        # Create an Elasticsearch client object.
        client = elasticsearch.Elasticsearch([hosts])

        # Index a few documents
        es_index = 'my_index'
        es_type = 'People'

        params = {
            "index": es_index,
            "type": es_type,
            "body": {"name": ''}
        }

        names = ['Ada Lovelace', 'Alonzo Church', 'Barbara Liskov']

        ids = {}

        for name in names:
            params['body']['name'] = name
            ids[name] = client.index(index=params["index"], doc_type=params["type"], body=params['body'])

        # Force just-added items to be indexed.
        client.indices.refresh(index=es_index)

        # Search for documents.
        result = client.search(index=es_index, body={
            'query': {
                'match': {
                    'name': 'Barbara Liskov'
                }
            }
        })

        table = '''<table>
<thead>
<tr><th>ID</th><th>Name</th></tr>
</thead>
<tbody>'''

        if result['hits']['hits']:
            for record in result['hits']['hits']:
                table += '''<tr><td>{0}</td><td>{1}</td><tr>\n'''.format(record['_id'], record['_source']['name'])
            table += '''</tbody>\n</table>\n'''

        # Delete documents.
        params = {
            "index": es_index,
            "type": es_type,
        }

        for name in names:
            client.delete(index=params['index'], doc_type=params['type'], id=ids[name]['_id'])

        return table

    except Exception as e:
        return e

package sh.platform.languages.sample;

import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.admin.indices.refresh.RefreshResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import sh.platform.config.Config;
import sh.platform.config.Elasticsearch;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

import static java.util.concurrent.ThreadLocalRandom.current;

public class ElasticsearchSample implements Supplier<String> {

    @Override
    public String get() {
        StringBuilder logger = new StringBuilder();

        // Create a new config object to ease reading the Platform.sh environment variables.
        // You can alternatively use getenv() yourself.
        Config config = new Config();

        Elasticsearch elasticsearch = config.getCredential("elasticsearch", Elasticsearch::new);

        // Create an Elasticsearch client object.
        RestHighLevelClient client = elasticsearch.get();

        try {

            String index = "animals";
            String type = "mammals";
            // Index a few document.
            final List<String> animals = Arrays.asList("dog", "cat", "monkey", "horse");
            for (String animal : animals) {
                Map<String, Object> jsonMap = new HashMap<>();
                jsonMap.put("name", animal);
                jsonMap.put("age", current().nextInt(1, 10));
                jsonMap.put("is_cute", current().nextBoolean());

                IndexRequest indexRequest = new IndexRequest(index, type)
                        .id(animal).source(jsonMap);
                client.index(indexRequest, RequestOptions.DEFAULT);
            }

            RefreshRequest refresh = new RefreshRequest(index);

            // Force just-added items to be indexed
            RefreshResponse refreshResponse = client.indices().refresh(refresh, RequestOptions.DEFAULT);

            // Search for documents.
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            sourceBuilder.query(QueryBuilders.termQuery("name", "dog"));
            SearchRequest searchRequest = new SearchRequest();
            searchRequest.indices(index);
            searchRequest.source(sourceBuilder);

            SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);

            for (SearchHit hit : search.getHits()) {
                String id = hit.getId();
                final Map<String, Object> source = hit.getSourceAsMap();
                logger.append(String.format("result id %s source: %s", id, source)).append('\n');
            }

            // Delete documents.
            for (String animal : animals) {
                client.delete(new DeleteRequest(index, type, animal), RequestOptions.DEFAULT);
            }
        } catch (IOException exp) {
            throw new RuntimeException("An error when execute Elasticsearch: " + exp.getMessage());
        }
        return logger.toString();
    }
}