Tweaks following review #2

src/frontend/packages/core/src/core/endpoints.service.ts

@@ -145,7 +145,7 @@ export class EndpointsService implements CanActivate {
             entityFactory(action.entityKey)
           )
         }).entities$.pipe(
-          filter(entities => !!entities && !!entities.length),
+          filter(entities => !!entities),
           map(entities => !!entities.find(entity => !!entity.data.result.length)),
           first()
         );

src/frontend/packages/core/src/features/metrics/metrics/metrics.component.html

@@ -33,15 +33,15 @@ <h2 class="metrics-url">
               <mat-icon fontSet="{{ ep.metadata[svc.guid].icon.font }}">{{ ep.metadata[svc.guid].icon.name }}</mat-icon>
               <div class="metrics-metadata">
                 <div>{{ svc.name }}</div>
-                <div>{{ ep.metadata[svc.guid].type }}</div>
+                <div>{{ ep.metadata[svc.guid].typeLabel }}</div>
                 <div class="metrics-metadata__cols">
                   <div class="metrics-metadata__two-cols">
                     <app-metadata-item icon="link" label="Address">{{ svc.metadata.fullApiEndpoint }}</app-metadata-item>
-                    <ng-container *ngIf="getKubeRelation(ep.entity.provider) as rel">
+                    <ng-container *ngIf="ep.metadata[svc.guid].type === 'k8s' && getKubeRelation(ep.entity.provider) as rel">
                         <app-metadata-item icon="history" label="Prometheus Job">{{ rel.metadata.metrics_job || 'N/A' }}</app-metadata-item>
                         <app-metadata-item icon="history" label="Prometheus Environment">{{ rel.metadata.metrics_environment || 'N/A' }}</app-metadata-item>
                     </ng-container>
-                    <ng-container *ngIf="getEiriniRelation(ep.entity.provider) as rel">
+                    <ng-container *ngIf="ep.metadata[svc.guid].type === 'k8s' && getEiriniRelation(ep.entity.provider) as rel">
                         <app-metadata-item icon="history" label="Eirini Pod Namespace">{{ rel.metadata.namespace || 'N/A' }}</app-metadata-item>
                     </ng-container>
                   </div>

src/frontend/packages/core/src/features/metrics/metrics/metrics.component.ts

@@ -64,7 +64,8 @@ export class MetricsComponent {
 
         Object.values(ep.endpoints).forEach(endpoint => {
           metadata[endpoint.guid] = {
-            type: getNameForEndpointType(endpoint.cnsi_type, endpoint.sub_type),
+            type: endpoint.cnsi_type,
+            typeLabel: getNameForEndpointType(endpoint.cnsi_type, endpoint.sub_type),
             icon: getIconForEndpoint(endpoint.cnsi_type, endpoint.sub_type),
           };
         });
@@ -114,7 +115,6 @@ export class MetricsComponent {
   }
 
   getRelation(endpoint: EndpointModel, relType: EndpointRelationTypes): EndpointsRelation {
-    console.log(endpoint, relType);
     return endpoint.relations ? endpoint.relations.provides.find(e => e.type === relType) : null;
   }
 }

src/frontend/packages/core/src/shared/components/markdown-preview/markdown-preview.component.ts

@@ -60,7 +60,6 @@ export class MarkdownPreviewComponent {
           const titleElement = h1[0];
           const titleText = titleElement.innerText;
           this.title = titleText;
-          // console.log('Got title: ' + titleText);
         }, 100);
       } else {
         this.title = 'Help';

src/jetstream/plugins/metrics/cloud_foundry.go

@@ -187,6 +187,7 @@ func (m *MetricsSpecification) makePrometheusRequest(c echo.Context, cnsiList []
 	// For each CNSI, find the metrics endpoint that we need to talk to
 	metrics, err2 := m.getMetricsEndpoints(userGUID, cnsiList)
 	if err2 != nil {
+		log.Error("Error getting metrics ", err2)
 		return errors.New("Can not get metric endpoint metadata")
 	}
 

src/jetstream/plugins/metrics/kubernetes.go

@@ -25,7 +25,7 @@ func (m *MetricsSpecification) getPodMetrics(c echo.Context) error {
 	// For each CNSI, find the metrics endpoint that we need to talk to
 	metrics, err2 := m.getMetricsEndpoints(userGUID, cnsiList)
 	if err2 != nil {
-		log.Error("Error getting metrics", err2)
+		log.Error("Error getting metrics ", err2)
 
 		return errors.New("Can not get metric endpoint metadata")
 	}

src/jetstream/plugins/metrics/main.go

@@ -372,7 +372,7 @@ func hasMetricsProvider(providers []MetricsMetadata, url string) (*MetricsMetada
 
 func (m *MetricsSpecification) getMetricsEndpoints(userGUID string, cnsiList []string) (map[string]EndpointMetricsRelation, error) {
 
-	metricsProviders := make([]MetricsMetadata, 0)
+	metricsMetadatas := make(map[string]MetricsMetadata)
 	endpointsMap := make(map[string]*interfaces.ConnectedEndpoint)
 	results := make(map[string]EndpointMetricsRelation)
 
@@ -383,13 +383,9 @@ func (m *MetricsSpecification) getMetricsEndpoints(userGUID string, cnsiList []s
 		return nil, err
 	}
 
-	// TODO: RC Should we not do this now and rely on the relations table?
-
 	for _, endpoint := range userEndpoints {
-		if stringInSlice(endpoint.GUID, cnsiList) {
-			// Found the Endpoint, so add it to our list
-			endpointsMap[endpoint.GUID] = endpoint
-		} else if endpoint.CNSIType == "metrics" {
+		endpointsMap[endpoint.GUID] = endpoint
+		if endpoint.CNSIType == "metrics" {
 			// Parse out the metadata
 			var m []MetricsProviderMetadata
 			err := json.Unmarshal([]byte(endpoint.TokenMetadata), &m)
@@ -401,43 +397,57 @@ func (m *MetricsSpecification) getMetricsEndpoints(userGUID string, cnsiList []s
 					info.URL = item.URL
 					info.Job = item.Job
 					info.Environment = item.Environment
-					metricsProviders = append(metricsProviders, info)
+					metricsMetadatas[endpoint.GUID+item.Type] = info
 				}
 			}
 		}
 	}
 
-	for _, metricProviderInfo := range metricsProviders {
-		for guid, info := range endpointsMap {
-			// Depends on the type
-			if info.CNSIType == metricProviderInfo.Type && info.DopplerLoggingEndpoint == metricProviderInfo.URL {
-				relate := EndpointMetricsRelation{}
-				relate.endpoint = info
-				// Make a copy
-				relate.metrics = &MetricsMetadata{}
-				*relate.metrics = metricProviderInfo
-				results[guid] = relate
-				delete(endpointsMap, guid)
-				break
+	for _, cnsiGuid := range cnsiList {
+		// Fetch a list of all relations with a provider for this endpoint
+		providers, err := m.portalProxy.ListRelationsByTarget(cnsiGuid)
+		if err != nil {
+			return nil, errors.New("Can not fetch list of targets for cnsi")
+		}
+
+		// Filter list down to either cf or kube metrics providers
+		metricsProviders := filterRelations(providers, func(v *interfaces.RelationsRecord) bool {
+			return v.RelationType == MetricsCfRelation || v.RelationType == MetricsKubeRelation
+		})
+
+		if len(metricsProviders) == 0 {
+			return nil, fmt.Errorf("Can not find a metric provider for endpoint %v", cnsiGuid)
+		}
+
+		// Create the results (list of unique <cf/kube endpoint and metrics relation>)
+		length := len(results)
+		for _, provider := range metricsProviders {
+			relate := EndpointMetricsRelation{}
+			relate.endpoint = endpointsMap[provider.Target]
+			if relate.endpoint == nil {
+				continue
 			}
-			// K8s
-			log.Debugf("Processing endpoint: %+v", info)
-			log.Debugf("Processing endpoint Metrics provider: %+v", metricProviderInfo)
-			if info.APIEndpoint.String() == metricProviderInfo.URL {
-				relate := EndpointMetricsRelation{}
-				relate.endpoint = info
-				relate.metrics = &metricProviderInfo
-				results[guid] = relate
-				delete(endpointsMap, guid)
-				break
+			var relationMap = ""
+			if provider.RelationType == MetricsCfRelation {
+				relationMap = "cf"
+			} else if provider.RelationType == MetricsCfRelation {
+				relationMap = "k8s"
 			}
+			if len(relationMap) == 0 {
+				return nil, fmt.Errorf("Unknown relation type %v", provider.RelationType)
+			}
+			// Make a copy
+			relate.metrics = &MetricsMetadata{}
+			*relate.metrics = metricsMetadatas[provider.Provider+relationMap]
+			results[provider.Provider] = relate
+		}
+
+		if length == len(results) {
+			return nil, fmt.Errorf("Can not find a connected metrics endpoint for endpoint %v", cnsiGuid)
 		}
-	}
 
-	// Did we find a metric provider for each endpoint?
-	if len(endpointsMap) != 0 {
-		return nil, errors.New("Can not find a metric provider for all of the specified endpoints")
 	}
+
 	return results, nil
 }
 
@@ -561,6 +571,16 @@ func filterEndpoints(vs []*interfaces.ConnectedEndpoint, f func(*interfaces.Conn
 	return vsf
 }
 
+func filterRelations(vs []*interfaces.RelationsRecord, f func(*interfaces.RelationsRecord) bool) []*interfaces.RelationsRecord {
+	vsf := make([]*interfaces.RelationsRecord, 0)
+	for _, v := range vs {
+		if f(v) {
+			vsf = append(vsf, v)
+		}
+	}
+	return vsf
+}
+
 // , user *interfaces.ConnectedUser
 func (m *MetricsSpecification) OnConnect(endpoint *interfaces.CNSIRecord, tokenRecord *interfaces.TokenRecord, consoleUserID string) {
 	log.Warnf("Metrics OnConnect")

src/jetstream/relations.go

@@ -28,6 +28,15 @@ func (p *portalProxy) ListRelations() ([]*interfaces.RelationsRecord, error) {
 	return store.List()
 }
 
+func (p *portalProxy) ListRelationsByTarget(target string) ([]*interfaces.RelationsRecord, error) {
+	store, err := relations.NewRelationsDBStore(p.DatabaseConnectionPool)
+	if err != nil {
+		return nil, err
+	}
+
+	return store.ListByTarget(target)
+}
+
 func (p *portalProxy) RemoveRelations(providerOrTarget string) error {
 	store, err := relations.NewRelationsDBStore(p.DatabaseConnectionPool)
 	if err != nil {

src/jetstream/repository/interfaces/portal_proxy.go

@@ -83,6 +83,7 @@ type PortalProxy interface {
 	// Relations
 	SaveRelation(relation RelationsRecord) (*RelationsRecord, error)
 	ListRelations() ([]*RelationsRecord, error)
+	ListRelationsByTarget(target string) ([]*RelationsRecord, error)
 	RemoveRelations(providerOrTarget string) error
 	RemoveRelation(relation RelationsRecord) error
 

src/jetstream/repository/relations/pgsql_relations.go

@@ -12,19 +12,21 @@ import (
 )
 
 var (
-	getRelations       = `SELECT provider, type, target, metadata FROM relations`
-	getRelationsByType = `SELECT provider, type, target, metadata FROM relations WHERE type = $1`
-	getRelation        = `SELECT provider, type, target, metadata FROM relations WHERE provider = $1 AND type = $2 AND target = $3`
-	deleteRelation     = `DELETE FROM relations WHERE provider = $1 AND type = $2 AND target = $3`
-	deleteRelations    = `DELETE FROM relations WHERE provider = $1 OR target = $2`
-	insertRelation     = `INSERT INTO relations (provider, type, target, metadata) VALUES ($1, $2, $3, $4)`
-	updateRelation     = `UPDATE relations SET provider = $1, type = $2, target = $3, metadata = $4 WHERE provider = $5 AND type = $6 AND target = $7`
+	getRelations         = `SELECT provider, type, target, metadata FROM relations`
+	getRelationsByType   = `SELECT provider, type, target, metadata FROM relations WHERE type = $1`
+	getRelationsByTarget = `SELECT provider, type, target, metadata FROM relations WHERE target = $1`
+	getRelation          = `SELECT provider, type, target, metadata FROM relations WHERE provider = $1 AND type = $2 AND target = $3`
+	deleteRelation       = `DELETE FROM relations WHERE provider = $1 AND type = $2 AND target = $3`
+	deleteRelations      = `DELETE FROM relations WHERE provider = $1 OR target = $2`
+	insertRelation       = `INSERT INTO relations (provider, type, target, metadata) VALUES ($1, $2, $3, $4)`
+	updateRelation       = `UPDATE relations SET provider = $1, type = $2, target = $3, metadata = $4 WHERE provider = $5 AND type = $6 AND target = $7`
 )
 
 // InitRepositoryProvider - One time init for the given DB Provider
 func InitRepositoryProvider(databaseProvider string) {
 	// Modify the database statements if needed, for the given database type
 	getRelationsByType = datastore.ModifySQLStatement(getRelationsByType, databaseProvider)
+	getRelationsByTarget = datastore.ModifySQLStatement(getRelationsByTarget, databaseProvider)
 	getRelation = datastore.ModifySQLStatement(getRelation, databaseProvider)
 	deleteRelation = datastore.ModifySQLStatement(deleteRelation, databaseProvider)
 	deleteRelations = datastore.ModifySQLStatement(deleteRelations, databaseProvider)
@@ -79,6 +81,46 @@ func (p *RelationsDBStore) List() ([]*interfaces.RelationsRecord, error) {
 	return relationsList, nil
 }
 
+// List - Returns a list of all relations
+func (p *RelationsDBStore) ListByTarget(target string) ([]*interfaces.RelationsRecord, error) {
+	log.Debug("ListByTarget")
+	rows, err := p.db.Query(getRelationsByTarget, target)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to retrieve Relations records: %v", err)
+	}
+	defer rows.Close()
+
+	var relationsList []*interfaces.RelationsRecord
+	relationsList = make([]*interfaces.RelationsRecord, 0)
+
+	for rows.Next() {
+		relation := new(interfaces.RelationsRecord)
+		var metaString sql.NullString
+		err := rows.Scan(&relation.Provider, &relation.RelationType, &relation.Target, &metaString)
+		if err != nil {
+			return nil, fmt.Errorf("Unable to scan Relations records: %v", err)
+		}
+
+		var metadata map[string]interface{}
+		err = json.Unmarshal([]byte(metaString.String), &metadata)
+		if err != nil {
+			return nil, fmt.Errorf("Unable to Marshal Relations metadata: %v", err)
+		}
+		relation.Metadata = metadata
+
+		log.Warnf("ListByTarget1 %+v", relation)
+
+		relationsList = append(relationsList, relation)
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, fmt.Errorf("Unable to List Relations records: %v", err)
+	}
+	log.Warnf("ListByTarget2 %+1", relationsList)
+
+	return relationsList, nil
+}
+
 func (p *RelationsDBStore) ListByType(relationType string) ([]*interfaces.RelationsRecord, error) {
 	log.Debug("ListByType")
 	rows, err := p.db.Query(getRelationsByType, relationType)

src/jetstream/repository/relations/relations.go

@@ -6,6 +6,7 @@ import (
 
 type RelationsStore interface {
 	List() ([]*interfaces.RelationsRecord, error)
+	ListByTarget(target string) ([]*interfaces.RelationsRecord, error)
 	ListByType(relationType string) ([]*interfaces.RelationsRecord, error)
 	DeleteRelation(provider string, relType string, target string) error
 	DeleteRelations(providerOrTarget string) error