Java IndicesAliasesRequest类代码示例

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
private void aliasActionToJson(IndicesAliasesRequest.AliasActions actions, String alias, String index, XContentBuilder builder) throws IOException {
    String filter = actions.aliasAction().filter();
    String indexRouting = actions.aliasAction().indexRouting();
    String searchRouting = actions.aliasAction().searchRouting();
    AliasAction.Type type = actions.aliasAction().actionType();

    builder.startObject();
    builder.startObject(type.name().toLowerCase());
    if (alias != null) {
        builder.field("alias", alias);
    }
    if (index != null) {
        builder.field("index", index);
    }
    if (filter != null) {
        builder.rawField("filter", filter.getBytes());
    }
    if (searchRouting != null) {
        builder.field("search_routing", searchRouting);
    }
    if (indexRouting != null) {
        builder.field("index_routing", indexRouting);
    }
    builder.endObject();
    builder.endObject();
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Test
public void should_create_alias() throws Exception {
    String index = "index_without_alias";
    createIndex(index);
    ensureGreen(index);

    IndicesAliasesRequest request = new IndicesAliasesRequest();
    request.addAlias("the_alias", index);
    IndicesAliasesResponse response = httpClient.admin().indices().aliases(request).get();

    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetAliasesResponse finalState = transportClient.admin().indices().getAliases(new GetAliasesRequest()).actionGet();
    Assertions.assertThat(finalState.getAliases().get(index)).hasSize(1);
    Assertions.assertThat(finalState.getAliases().get(index).get(0).alias()).isEqualTo("the_alias");
    Assertions.assertThat(finalState.getAliases().get(index).get(0).filter()).isNull();
    Assertions.assertThat(finalState.getAliases().get(index).get(0).getIndexRouting()).isNull();
    Assertions.assertThat(finalState.getAliases().get(index).get(0).getSearchRouting()).isNull();
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Test
public void should_delete_alias() throws Exception {
    String index = "index_without_alias";
    createIndex(index);
    ensureGreen(index);

    transportClient.admin().indices().aliases(new IndicesAliasesRequest().addAlias("the_alias", index)).actionGet();
    GetAliasesResponse actualAlias = transportClient.admin().indices().getAliases(new GetAliasesRequest().indices(index)).actionGet();
    Assertions.assertThat(actualAlias.getAliases().containsKey(index)).isTrue();
    Assertions.assertThat(actualAlias.getAliases().get(index)).hasSize(1);
    Assertions.assertThat(actualAlias.getAliases().get(index).get(0).alias()).isEqualTo("the_alias");

    IndicesAliasesRequest request = new IndicesAliasesRequest();
    request.removeAlias(index, "the_alias");
    IndicesAliasesResponse response = httpClient.admin().indices().aliases(request).get();

    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetAliasesResponse finalState = transportClient.admin().indices().getAliases(new GetAliasesRequest()).actionGet();
    Assertions.assertThat(finalState.getAliases()).hasSize(0);
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Test
public void should_create_alias_with_filter() throws Exception {
    String index = "index_without_alias";
    createIndex(index);
    ensureGreen(index);

    // add a mapping so I can add a filter, else it will fail due to strict resolution of fields
    createSimpleDoc(index, THE_TYPE, THE_ID);
    ensureSearchable(index);

    IndicesAliasesRequest request = new IndicesAliasesRequest();
    TermFilterBuilder filter = termFilter("the_string_field", "some_value");

    request.addAlias("the_alias", filter, index);
    IndicesAliasesResponse response = httpClient.admin().indices().aliases(request).get();

    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetAliasesResponse finalState = transportClient.admin().indices().getAliases(new GetAliasesRequest()).actionGet();
    Assertions.assertThat(finalState.getAliases().get(index)).hasSize(1);
    Assertions.assertThat(finalState.getAliases().get(index).get(0).alias()).isEqualTo("the_alias");

    String requestFilter = request.getAliasActions().get(0).aliasAction().filter();
    CompressedString actualFilter = finalState.getAliases().get(index).get(0).filter();
    Assertions.assertThat(actualFilter.string()).isEqualTo(requestFilter);
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Test
public void should_create_alias_with_routing() throws Exception {
    String index = "index_without_alias";
    createIndex(index);
    ensureGreen(index);

    IndicesAliasesRequest request = new IndicesAliasesRequest();

    request.addAliasAction(new AliasAction(AliasAction.Type.ADD).alias("the_alias").index(index).searchRouting("the_search_routing").indexRouting("the_index_routing"));
    IndicesAliasesResponse response = httpClient.admin().indices().aliases(request).get();

    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetAliasesResponse finalState = transportClient.admin().indices().getAliases(new GetAliasesRequest()).actionGet();
    Assertions.assertThat(finalState.getAliases().get(index)).hasSize(1);
    Assertions.assertThat(finalState.getAliases().get(index).get(0).alias()).isEqualTo("the_alias");
    Assertions.assertThat(finalState.getAliases().get(index).get(0).searchRouting()).isEqualTo("the_search_routing");
    Assertions.assertThat(finalState.getAliases().get(index).get(0).indexRouting()).isEqualTo("the_index_routing");
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    final String[] aliases = Strings.splitStringByCommaToArray(request.param("name"));
    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    indicesAliasesRequest.addAliasAction(AliasActions.remove().indices(indices).aliases(aliases));
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));

    return channel -> client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    try (XContentParser parser = request.contentParser()) {
        PARSER.parse(parser, indicesAliasesRequest, null);
    }
    if (indicesAliasesRequest.getAliasActions().isEmpty()) {
        throw new IllegalArgumentException("No action specified");
    }
    return channel -> client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    final String[] aliases = Strings.splitStringByCommaToArray(request.param("name"));
    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    indicesAliasesRequest.removeAlias(indices, aliases);
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));

    client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<IndicesAliasesResponse>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
public boolean addAlias(String indexName,String indexAlias) {
    try {
        esClient.admin().indices().aliases(new IndicesAliasesRequest().addAlias(indexAlias,indexName)).actionGet();
        return true;
    } catch(Exception e) {
        return false;
    }
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
protected XContentBuilder toXContent(IndicesAliasesRequest request, IndicesAliasesResponse response, XContentBuilder builder) throws IOException {
    builder.startObject()
            .field(Fields.OK, true)
            .field(Fields.ACKNOWLEDGED, response.isAcknowledged())
            .endObject();
    return builder;
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
public ActionFuture<IndicesAliasesResponse> aliases(final IndicesAliasesRequest request) {
    return execute(IndicesAliasesAction.INSTANCE, request);
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    String alias = request.param("name");
    Map<String, Object> filter = null;
    String routing = null;
    String indexRouting = null;
    String searchRouting = null;

    if (request.hasContent()) {
        try (XContentParser parser = request.contentParser()) {
            XContentParser.Token token = parser.nextToken();
            if (token == null) {
                throw new IllegalArgumentException("No index alias is specified");
            }
            String currentFieldName = null;
            while ((token = parser.nextToken()) != null) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if ("index".equals(currentFieldName)) {
                        indices = Strings.splitStringByCommaToArray(parser.text());
                    } else if ("alias".equals(currentFieldName)) {
                        alias = parser.text();
                    } else if ("routing".equals(currentFieldName)) {
                        routing = parser.textOrNull();
                    } else if ("indexRouting".equals(currentFieldName)
                            || "index-routing".equals(currentFieldName) || "index_routing".equals(currentFieldName)) {
                        indexRouting = parser.textOrNull();
                    } else if ("searchRouting".equals(currentFieldName)
                            || "search-routing".equals(currentFieldName) || "search_routing".equals(currentFieldName)) {
                        searchRouting = parser.textOrNull();
                    }
                } else if (token == XContentParser.Token.START_OBJECT) {
                    if ("filter".equals(currentFieldName)) {
                        filter = parser.mapOrdered();
                    }
                }
            }
        }
    }

    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));

    IndicesAliasesRequest.AliasActions aliasAction = AliasActions.add().indices(indices).alias(alias);
    if (routing != null) {
        aliasAction.routing(routing);
    }
    if (searchRouting != null) {
        aliasAction.searchRouting(searchRouting);
    }
    if (indexRouting != null) {
        aliasAction.indexRouting(indexRouting);
    }
    if (filter != null) {
        aliasAction.filter(filter);
    }
    indicesAliasesRequest.addAliasAction(aliasAction);
    return channel -> client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) throws Exception {
    String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    String alias = request.param("name");
    Map<String, Object> filter = null;
    String routing = null;
    String indexRouting = null;
    String searchRouting = null;

    if (request.hasContent()) {
        try (XContentParser parser = XContentFactory.xContent(request.content()).createParser(request.content())) {
            XContentParser.Token token = parser.nextToken();
            if (token == null) {
                throw new IllegalArgumentException("No index alias is specified");
            }
            String currentFieldName = null;
            while ((token = parser.nextToken()) != null) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if ("index".equals(currentFieldName)) {
                        indices = Strings.splitStringByCommaToArray(parser.text());
                    } else if ("alias".equals(currentFieldName)) {
                        alias = parser.text();
                    } else if ("routing".equals(currentFieldName)) {
                        routing = parser.textOrNull();
                    } else if ("indexRouting".equals(currentFieldName) || "index-routing".equals(currentFieldName) || "index_routing".equals(currentFieldName)) {
                        indexRouting = parser.textOrNull();
                    } else if ("searchRouting".equals(currentFieldName) || "search-routing".equals(currentFieldName) || "search_routing".equals(currentFieldName)) {
                        searchRouting = parser.textOrNull();
                    }
                } else if (token == XContentParser.Token.START_OBJECT) {
                    if ("filter".equals(currentFieldName)) {
                        filter = parser.mapOrdered();
                    }
                }
            }
        }
    }

    IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
    indicesAliasesRequest.timeout(request.paramAsTime("timeout", indicesAliasesRequest.timeout()));
    String[] aliases = new String[]{alias};
    IndicesAliasesRequest.AliasActions aliasAction = new AliasActions(AliasAction.Type.ADD, indices, aliases);
    indicesAliasesRequest.addAliasAction(aliasAction);
    indicesAliasesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", indicesAliasesRequest.masterNodeTimeout()));


    if (routing != null) {
        aliasAction.routing(routing);
    }
    if (searchRouting != null) {
        aliasAction.searchRouting(searchRouting);
    }
    if (indexRouting != null) {
        aliasAction.indexRouting(indexRouting);
    }
    if (filter != null) {
        aliasAction.filter(filter);
    }
    client.admin().indices().aliases(indicesAliasesRequest, new AcknowledgedRestListener<IndicesAliasesResponse>(channel));
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Test
public void testBasicAggregations() throws Exception {
    final Settings settings = Settings.builder()
            .build();
    
    setup(settings);
    final RestHelper rh = nonSslRestHelper();

    try (TransportClient tc = getInternalTransportClient()) {                    
        tc.admin().indices().create(new CreateIndexRequest("copysf")).actionGet();         
        tc.index(new IndexRequest("vulcangov").type("kolinahr").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();                
        tc.index(new IndexRequest("starfleet").type("ships").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("starfleet_academy").type("students").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("starfleet_library").type("public").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("klingonempire").type("ships").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("public").type("legends").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
 
        tc.index(new IndexRequest("spock").type("type01").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("kirk").type("type01").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("role01_role02").type("type01").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();

        tc.admin().indices().aliases(new IndicesAliasesRequest().addAliasAction(AliasActions.add().indices("starfleet","starfleet_academy","starfleet_library").alias("sf"))).actionGet();
        tc.admin().indices().aliases(new IndicesAliasesRequest().addAliasAction(AliasActions.add().indices("klingonempire","vulcangov").alias("nonsf"))).actionGet();
        tc.admin().indices().aliases(new IndicesAliasesRequest().addAliasAction(AliasActions.add().indices("public").alias("unrestricted"))).actionGet();

    }
    
    HttpResponse res;
    Assert.assertEquals(HttpStatus.SC_OK, (res = rh.executePostRequest("_search?pretty", "{\"size\":0,\"aggs\":{\"indices\":{\"terms\":{\"field\":\"_index\",\"size\":40}}}}",encodeBasicHeader("nagilum", "nagilum"))).getStatusCode());
    System.out.println(res.getBody());
    assertNotContains(res, "*xception*");
    assertNotContains(res, "*erial*");
    assertNotContains(res, "*mpty*");
    assertNotContains(res, "*earchguard*");
    assertContains(res, "*vulcangov*");
    assertContains(res, "*\"failed\" : 0*");
    
    Assert.assertEquals(HttpStatus.SC_OK, (res = rh.executePostRequest("*/_search?pretty", "{\"size\":0,\"aggs\":{\"indices\":{\"terms\":{\"field\":\"_index\",\"size\":40}}}}",encodeBasicHeader("nagilum", "nagilum"))).getStatusCode());
    System.out.println(res.getBody());
    assertNotContains(res, "*xception*");
    assertNotContains(res, "*erial*");
    assertNotContains(res, "*mpty*");
    assertNotContains(res, "*earchguard*");
    assertContains(res, "*vulcangov*");
    assertContains(res, "*\"failed\" : 0*");
    
    Assert.assertEquals(HttpStatus.SC_OK, (res = rh.executePostRequest("_search?pretty", "{\"size\":0,\"aggs\":{\"indices\":{\"terms\":{\"field\":\"_index\",\"size\":40}}}}",encodeBasicHeader("worf", "worf"))).getStatusCode());
    System.out.println(res.getBody());
    assertNotContains(res, "*xception*");
    assertNotContains(res, "*erial*");
    assertNotContains(res, "*mpty*");
    assertNotContains(res, "*earchguard*");
    assertContains(res, "*vulcangov*");
    assertContains(res, "*\"failed\" : 0*");
    
    Assert.assertEquals(HttpStatus.SC_FORBIDDEN, (res = rh.executePostRequest("_search?pretty", "{\"size\":0,\"aggs\":{\"myindices\":{\"terms\":{\"field\":\"_index\",\"size\":40}}}}",encodeBasicHeader("worf", "worf"))).getStatusCode());
    
}
 

import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; //导入依赖的package包/类
@Test
public void testAliases() throws Exception {

    final Settings settings = Settings.builder()
            .put(ConfigConstants.SEARCHGUARD_ROLES_MAPPING_RESOLUTION, "BOTH")
            .build();

    setup(settings);

    try (TransportClient tc = getInternalTransportClient()) {
        tc.index(new IndexRequest("nopermindex").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();

        tc.index(new IndexRequest("logstash-1").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("logstash-2").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("logstash-3").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("logstash-4").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("logstash-5").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("logstash-del").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
        tc.index(new IndexRequest("logstash-del-ok").type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();

        String date = new SimpleDateFormat("YYYY.MM.dd").format(new Date());
        tc.index(new IndexRequest("logstash-"+date).type("logs").setRefreshPolicy(RefreshPolicy.IMMEDIATE).source("{\"content\":1}", XContentType.JSON)).actionGet();
    
        tc.admin().indices().aliases(new IndicesAliasesRequest().addAliasAction(AliasActions.add().indices("nopermindex").alias("nopermalias"))).actionGet();
    }
    
    RestHelper rh = nonSslRestHelper();
    
    HttpResponse res = null;
    
    System.out.println("#### add alias to allowed index");
    Assert.assertEquals(HttpStatus.SC_OK, (res = rh.executePutRequest("/logstash-1/_alias/alog1", "",encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());

    System.out.println("#### add alias to not existing (no perm)");
    Assert.assertEquals(HttpStatus.SC_FORBIDDEN, (res = rh.executePutRequest("/nonexitent/_alias/alnp", "",encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());
    
    System.out.println("#### add alias to not existing (with perm)");
    Assert.assertEquals(HttpStatus.SC_NOT_FOUND, (res = rh.executePutRequest("/logstash-nonex/_alias/alnp", "",encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());
    
    System.out.println("#### add alias to not allowed index");
    Assert.assertEquals(HttpStatus.SC_FORBIDDEN, (res = rh.executePutRequest("/nopermindex/_alias/alnp", "",encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());

    String aliasRemoveIndex = "{"+
        "\"actions\" : ["+
           "{ \"add\":  { \"index\": \"logstash-del-ok\", \"alias\": \"logstash-del\" } },"+
           "{ \"remove_index\": { \"index\": \"logstash-del\" } }  "+
        "]"+
    "}";
    
    System.out.println("#### remove_index");
    Assert.assertEquals(HttpStatus.SC_FORBIDDEN, (res = rh.executePostRequest("/_aliases", aliasRemoveIndex,encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());

    
    System.out.println("#### get alias for permitted index");
    Assert.assertEquals(HttpStatus.SC_OK, (res = rh.executeGetRequest("/logstash-1/_alias/alog1", encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());

    
    System.out.println("#### get alias for all indices");
    Assert.assertEquals(HttpStatus.SC_FORBIDDEN, (res = rh.executeGetRequest("/_alias/alog1", encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());

    
    System.out.println("#### get alias no perm");
    Assert.assertEquals(HttpStatus.SC_FORBIDDEN, (res = rh.executeGetRequest("/_alias/nopermalias", encodeBasicHeader("aliasmngt", "nagilum"))).getStatusCode());
}