public configureAvailableSecurityGroups(command: IEcsServerGroupCommand): void {
if (command.subnetType == null) {
command.backingData.filtered.securityGroups = [];
return;
}
const vpcId = chain(command.backingData.subnets)
.filter({
account: command.credentials,
region: command.region,
purpose: command.subnetType,
})
.compact()
.uniqBy('purpose')
.map('vpcId')
.value()[0];
if (
command.backingData.securityGroups[command.credentials] &&
command.backingData.securityGroups[command.credentials]['ecs'] &&
command.backingData.securityGroups[command.credentials]['ecs'][command.region]
) {
const allSecurityGroups = command.backingData.securityGroups[command.credentials]['ecs'][command.region];
command.backingData.filtered.securityGroupNames = chain(allSecurityGroups)
.filter({ vpcId: vpcId })
.map('name')
.value();
}
}
public normalizeLoadBalancer(loadBalancer: IAmazonLoadBalancer): IPromise<IAmazonLoadBalancer> {
this.normalizeServerGroups(loadBalancer.serverGroups, loadBalancer, 'loadBalancers', 'LoadBalancer');
let serverGroups = loadBalancer.serverGroups;
if ((loadBalancer as IAmazonApplicationLoadBalancer).targetGroups) {
const appLoadBalancer = loadBalancer as IAmazonApplicationLoadBalancer;
appLoadBalancer.targetGroups.forEach(targetGroup => this.normalizeTargetGroup(targetGroup));
serverGroups = flatten<IAmazonServerGroup>(map(appLoadBalancer.targetGroups, 'serverGroups'));
}
loadBalancer.loadBalancerType = loadBalancer.loadBalancerType || 'classic';
loadBalancer.provider = loadBalancer.type;
this.normalizeActions(loadBalancer as IAmazonApplicationLoadBalancer);
const activeServerGroups = filter(serverGroups, { isDisabled: false });
loadBalancer.instances = chain(activeServerGroups)
.map('instances')
.flatten<IInstance>()
.value();
loadBalancer.detachedInstances = chain(activeServerGroups)
.map('detachedInstances')
.flatten<IInstance>()
.value();
this.updateHealthCounts(loadBalancer);
return VpcReader.listVpcs().then(
(vpcs: IVpc[]) => this.addVpcNameToContainer(loadBalancer)(vpcs) as IAmazonLoadBalancer,
);
}
private buildInstanceCounts(serverGroups: IServerGroup[]): IInstanceCounts {
const instanceCounts = chain(serverGroups)
.map(serverGroup => serverGroup.instances)
.flatten()
.reduce(
(acc: IInstanceCounts, instance: any) => {
acc[camelCase(instance.health.state) as keyof IInstanceCounts]++;
return acc;
},
{
up: 0,
down: 0,
outOfService: 0,
succeeded: 0,
failed: 0,
unknown: 0,
starting: 0,
},
)
.value();
instanceCounts.outOfService += chain(serverGroups)
.map(serverGroup => serverGroup.detachedInstances)
.flatten()
.value().length;
return instanceCounts;
}
const uniqueValues = await (async (): Promise<Relation<string[]>> => {
let allValues = {
accounts : [],
categories : [],
subcategories: [],
payeePayers : [],
tags : []
} as Relation<string[]>;
importedCsv.forEach((item) => {
allValues.accounts .push(item['Account']);
allValues.accounts .push(item['AccountTo']);
allValues.categories .push(item['Category']);
allValues.subcategories.push(item['Subcategory']);
allValues.payeePayers .push(item['Payee/Payer']);
allValues.tags .push(item['Tag']);
});
return {
accounts : lodash.chain(allValues.accounts) .uniq().value(),
categories : lodash.chain(allValues.categories) .uniq().value(),
subcategories: lodash.chain(allValues.subcategories).uniq().value(),
payeePayers : lodash.chain(allValues.payeePayers) .uniq().value(),
tags : lodash.chain(allValues.tags) .uniq().value()
};
})();
private normalizeTargetGroup(targetGroup: ITargetGroup): IPromise<ITargetGroup> {
this.normalizeServerGroups(targetGroup.serverGroups, targetGroup, 'targetGroups', 'TargetGroup');
const activeServerGroups = filter(targetGroup.serverGroups, { isDisabled: false });
targetGroup.provider = targetGroup.type;
targetGroup.instances = chain(activeServerGroups)
.map('instances')
.flatten<IInstance>()
.value();
targetGroup.detachedInstances = chain(activeServerGroups)
.map('detachedInstances')
.flatten<IInstance>()
.value();
this.updateHealthCounts(targetGroup);
return $q.all([VpcReader.listVpcs(), AccountService.listAllAccounts()]).then(([vpcs, accounts]) => {
const tg = this.addVpcNameToContainer(targetGroup)(vpcs) as ITargetGroup;
tg.serverGroups = tg.serverGroups.map(serverGroup => {
const account = accounts.find(x => x.name === serverGroup.account);
const cloudProvider = serverGroup.cloudProvider || (account && account.cloudProvider);
serverGroup.instances.forEach(instance => {
instance.cloudProvider = cloudProvider;
instance.provider = cloudProvider;
});
return { ...serverGroup, cloudProvider };
});
return tg;
});
}
export function convert(docs: swagger.ApiDefinition, resource?: string): string {
let resources = _.pick(docs.paths, (operations: any, path: string) => resource ? repository.normalize(path).startsWith(resource) : true)
let pathLength = 25
let methodLength = 3
_.chain(resources)
.forEach((operations, path: string) => {
_.chain(operations)
.forEach((operation, method: string) => {
methodLength = Math.max(method.length, methodLength)
})
.value()
pathLength = Math.max(path.length, pathLength)
})
.value();
methodLength = methodLength + 2
return _.chain(resources)
.map((operations: swagger.PathsObject, path: string) => {
return _.chain(operations)
.map((operation: swagger.OperationObject, method: string) =>
`${sprintf(`%-${methodLength}s`, '['+method+']')} ${sprintf(`%-${pathLength}s`, path)} [[b;#fff;]${operation.summary}]`
)
.value()
.join('\n');
})
.value()
.join('\n');
}
).map(([sentences, answers]) => [
_.chain(sentences).map(
sentence => sentence.words.filter(
word => sentence.missing_words_positions.indexOf(sentence.words.indexOf(word)) >= 0
)
).flatten().value() as String[],
_.chain(answers).map(answer => _.values(answer)).flatten().map((answer: { word: String }) => answer.word).value()
]).map(([sentences, answers]) => { console.log(answers); return _.difference(sentences, answers) });
private normalizeTargetGroup(targetGroup: ITargetGroup): IPromise<ITargetGroup> {
this.normalizeServerGroups(targetGroup.serverGroups, targetGroup, 'targetGroups', 'TargetGroup');
const activeServerGroups = filter(targetGroup.serverGroups, {isDisabled: false});
targetGroup.provider = targetGroup.type;
targetGroup.instances = chain(activeServerGroups).map('instances').flatten<IInstance>().value();
targetGroup.detachedInstances = chain(activeServerGroups).map('detachedInstances').flatten<IInstance>().value();
this.updateHealthCounts(targetGroup);
return this.vpcReader.listVpcs().then((vpcs: IVpc[]) => this.addVpcNameToContainer(targetGroup)(vpcs) as ITargetGroup);
}
private buildInstanceCounts(serverGroups: ServerGroup[]): InstanceCounts {
const instanceCounts: InstanceCounts = chain(serverGroups)
.map('instances')
.flatten()
.reduce((acc: InstanceCounts, instance: any) => {
if (has(instance, 'health.state')) {
acc[camelCase(instance.health.state)]++;
}
return acc;
}, {up: 0, down: 0, outOfService: 0, succeeded: 0, failed: 0, unknown: 0}).value();
instanceCounts.outOfService += chain(serverGroups).map('detachedInstances').flatten().value().length;
return instanceCounts;
}
return get_es("/_aliases").then((indices) => {
// The aliases endpoint returns a map from index name to metadata about those indexes.
// e.g.
// {
// ".kibana-4": {
// "aliases": {}
// },
// "logs-2016-04-02": {
// "aliases": {
// "last_2days": {},
// "last_2weeks": {},
// "last_day": {},
// "last_week": {}
// }
// },
// }
// It's much easier to work with a map from alias name to list of indexes in the alias.
const aliases = {};
for (const index of Object.keys(indices)) {
for (const alias of Object.keys(indices[index].aliases)) {
if (!aliases[alias]) {
aliases[alias] = [];
}
aliases[alias].push(index);
// Keep the results sorted and unique
aliases[alias] = _.chain(aliases[alias]).sortBy(_.identity).uniq(true).value();
}
}
return aliases;
});
