@spinnaker/core 2025.1.4 → 2025.2.1

package/dist/loadBalancer/details/LoadBalancerDetails.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { ILoadBalancerDetailsProps } from './LoadBalancerDetailsWrapper';
+export declare function LoadBalancerDetailsContent({ app, loadBalancer: params, useDetails, Actions, sections, }: ILoadBalancerDetailsProps): JSX.Element;

package/dist/loadBalancer/details/LoadBalancerDetailsWrapper.d.ts

@@ -0,0 +1,37 @@
+import type { FunctionComponent } from 'react';
+import type { Application } from '../../application';
+import type { ILoadBalancer } from '../../domain';
+import type { ILoadBalancerStateParams } from '../loadBalancer.states';
+import type { IOverridableProps } from '../../overrideRegistry';
+export interface ILoadBalancerDetailsWrapperProps extends IOverridableProps {
+    app: Application;
+    loadBalancer: ILoadBalancerStateParams;
+}
+export interface UseDetailsResult<T> {
+    data: T | undefined;
+    loading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+}
+export interface IUseDetailsHookProps {
+    app: Application;
+    loadBalancerParams: ILoadBalancerStateParams;
+    autoClose: () => void;
+}
+export type UseDetailsHook<T> = (props: IUseDetailsHookProps) => UseDetailsResult<T>;
+export interface ILoadBalancerDetailsSectionProps {
+    app: Application;
+    loadBalancer: ILoadBalancer;
+}
+export interface ILoadBalancerActionsProps {
+    app: Application;
+    loadBalancer: ILoadBalancer;
+}
+export interface ILoadBalancerDetailsProps extends ILoadBalancerDetailsWrapperProps {
+    useDetails: UseDetailsHook<ILoadBalancer>;
+    Actions: FunctionComponent<ILoadBalancerActionsProps>;
+    sections: Array<FunctionComponent<ILoadBalancerDetailsSectionProps>>;
+}
+declare function LoadBalancerDetailsWrapper({ app, loadBalancer }: ILoadBalancerDetailsWrapperProps): JSX.Element;
+export declare const LoadBalancerDetails: typeof LoadBalancerDetailsWrapper;
+export {};

package/dist/loadBalancer/details/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoadBalancerDetails';
+export * from './LoadBalancerDetailsWrapper';

package/dist/loadBalancer/index.d.ts

@@ -6,3 +6,4 @@ export * from './LoadBalancerClusterContainer';
 export * from './LoadBalancerInstances';
 export * from './LoadBalancerServerGroup';
 export * from './LoadBalancersTagWrapper';
+export * from './details';

package/dist/loadBalancer/loadBalancer.states.d.ts

@@ -1 +1,8 @@
+export interface ILoadBalancerStateParams {
+    name: string;
+    accountId: string;
+    region: string;
+    vpcId: string;
+    provider: string;
+}
 export declare const LOAD_BALANCER_STATES = "spinnaker.core.loadBalancer.states";

package/dist/presentation/modal/index.d.ts

@@ -3,3 +3,4 @@ export * from './ModalHeader';
 export * from './ModalBody';
 export * from './ModalFooter';
 export * from './showModal';
+export * from './useModal';

package/dist/presentation/modal/useModal.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Custom hook to manage modal visibility.
+ * Provides methods to open and close a modal.
+ *
+ * @param {UseModalProps} [props] - Configuration options for initial modal state.
+ * @param {boolean} [props.defaultOpen=false] - Initial visibility state of the modal.
+ * @returns {UseModalReturn} - The current state and control methods for the modal.
+ */
+export type UseModalReturn = {
+    open: boolean;
+    show: () => void;
+    close: () => void;
+};
+/**
+ * Configuration options for the useModal hook.
+ *
+ * @typedef {Object} UseModalProps
+ * @property {boolean} [defaultOpen=false] - Initial state of the modal.
+ */
+export type UseModalProps = {
+    defaultOpen?: boolean;
+};
+/**
+ * Hook to control modal visibility.
+ * Returns methods to open and close a modal, and the modal's current state.
+ *
+ * @param {UseModalProps} [props] - The configuration for the modal.
+ * @returns {UseModalReturn} - Modal visibility state and control methods.
+ */
+export declare const useModal: ({ defaultOpen }?: UseModalProps) => UseModalReturn;

package/dist/task/index.d.ts

@@ -1,6 +1,7 @@
 export * from './PlatformHealthOverrideMessage';
 export * from './monitor/TaskMonitor';
 export * from './monitor/TaskMonitorWrapper';
+export * from './monitor/useTaskMonitor';
 export * from './modal/TaskReason';
 export * from './modal/TaskMonitorModal';
 export * from './task.read.service';

package/dist/task/monitor/useTaskMonitor.d.ts

@@ -0,0 +1,25 @@
+import type { ITaskMonitorConfig } from './TaskMonitor';
+import { TaskMonitor } from './TaskMonitor';
+/**
+ * React hook that returns a TaskMonitor
+ *
+ * @param config a ITaskMonitorConfig
+ * @param dismissModal a function that closes the modal enclosing the task monitor
+ *
+ * Example:
+ *
+ * function MyComponent(props) {
+ *   const { application, serverGroup } = props;
+ *   const title = `Resize ${serverGroup.name}`;
+ *   const taskMonitor = useTaskMonitor({ application, title });
+ *
+ *   return (
+ *     <>
+ *       <TaskMonitorWrapper taskMonitor={taskMonitor}>
+ *       <form onSubmit={() => taskMonitor.submit(() => API.runSomeTask())}>
+ *     </>
+ *   )
+ * }
+ *
+ */
+export declare const useTaskMonitor: (config: ITaskMonitorConfig, dismissModal: () => void) => TaskMonitor;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/core",
   "license": "Apache-2.0",
-  "version": "2025.1.4",
+  "version": "2025.2.1",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "publishConfig": {
@@ -124,5 +124,5 @@
     "shx": "0.3.3",
     "typescript": "5.0.4"
   },
-  "gitHead": "9d7aa2b1efc3f4fcb545a8578ee72e41f4cf88cd"
+  "gitHead": "33bad18275d63c4000a8e757cc0b4816e2e7eed5"
 }

package/src/domain/ILoadBalancer.ts

@@ -13,6 +13,7 @@ export interface ILoadBalancerSourceData {
 }
 
 export interface ILoadBalancer extends ITaggedEntity, IManagedResource {
+  [key: string]: any;
   account?: string;
   cloudProvider?: string;
   detail?: string;

package/src/loadBalancer/details/LoadBalancerDetails.tsx

@@ -0,0 +1,64 @@
+import { useRouter } from '@uirouter/react';
+import React, { useEffect, useState } from 'react';
+
+import type { ILoadBalancerDetailsProps } from './LoadBalancerDetailsWrapper';
+import { CloudProviderLogo } from '../../cloudProvider';
+import { EntityNotifications } from '../../entityTag/notifications/EntityNotifications';
+import { Details } from '../../presentation';
+import { IfFeatureEnabled } from '../../utils';
+
+export function LoadBalancerDetailsContent({
+  app,
+  loadBalancer: params,
+  useDetails,
+  Actions,
+  sections,
+}: ILoadBalancerDetailsProps) {
+  const [initialized, setInitialized] = useState(false);
+  const {
+    stateService: { go },
+  } = useRouter();
+  const autoClose = () => {
+    go('^', { allowModalToStayOpen: true }, { location: 'replace' });
+  };
+  const { data: loadBalancer, loading } = useDetails({ app, loadBalancerParams: params, autoClose });
+
+  useEffect(() => {
+    if (loadBalancer) {
+      setInitialized(true);
+    }
+  }, [loading]);
+
+  if (!initialized) return <Details loading={loading} />;
+
+  return (
+    <Details loading={loading}>
+      <Details.Header
+        icon={<CloudProviderLogo provider={params.provider} height="36px" width="36px" />}
+        name={loadBalancer.displayName ? loadBalancer.displayName : loadBalancer.name}
+        notifications={
+          <IfFeatureEnabled
+            feature="entityTags"
+            render={
+              <EntityNotifications
+                entity={loadBalancer}
+                application={app}
+                placement="bottom"
+                hOffsetPercent="90%"
+                entityType="loadBalancer"
+                pageLocation="details"
+                onUpdate={() => app.loadBalancers.refresh()}
+              />
+            }
+          />
+        }
+        actions={<Actions key="actions" app={app} loadBalancer={loadBalancer} />}
+      />
+      <Details.Content loading={loading}>
+        {sections.map((Section, index) => (
+          <Section key={index} app={app} loadBalancer={loadBalancer} />
+        ))}
+      </Details.Content>
+    </Details>
+  );
+}

package/src/loadBalancer/details/LoadBalancerDetailsWrapper.tsx

@@ -0,0 +1,120 @@
+import { $templateCache } from 'ngimport';
+import type { FunctionComponent } from 'react';
+import React from 'react';
+
+import { LoadBalancerDetailsContent } from './LoadBalancerDetails';
+import type { Application } from '../../application';
+import { CloudProviderRegistry } from '../../cloudProvider';
+import type { ILoadBalancer } from '../../domain';
+import type { ILoadBalancerStateParams } from '../loadBalancer.states';
+import type { IOverridableProps } from '../../overrideRegistry';
+import { overridableComponent } from '../../overrideRegistry';
+import { useData } from '../../presentation';
+import { AngularJSAdapter } from '../../reactShims';
+
+export interface ILoadBalancerDetailsWrapperProps extends IOverridableProps {
+  app: Application;
+  loadBalancer: ILoadBalancerStateParams;
+}
+
+export interface UseDetailsResult<T> {
+  data: T | undefined;
+  loading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+}
+
+export interface IUseDetailsHookProps {
+  app: Application;
+  loadBalancerParams: ILoadBalancerStateParams;
+  autoClose: () => void;
+}
+
+export type UseDetailsHook<T> = (props: IUseDetailsHookProps) => UseDetailsResult<T>;
+
+export interface ILoadBalancerDetailsSectionProps {
+  app: Application;
+  loadBalancer: ILoadBalancer;
+}
+
+export interface ILoadBalancerActionsProps {
+  app: Application;
+  loadBalancer: ILoadBalancer;
+}
+
+export interface ILoadBalancerDetailsProps extends ILoadBalancerDetailsWrapperProps {
+  useDetails: UseDetailsHook<ILoadBalancer>;
+  Actions: FunctionComponent<ILoadBalancerActionsProps>;
+  sections: Array<FunctionComponent<ILoadBalancerDetailsSectionProps>>;
+}
+
+interface IDetailsTemplateState {
+  detailsTemplateUrl?: string;
+  detailsController?: string;
+  useDetailsHook?: UseDetailsHook<ILoadBalancer>;
+  detailsActions?: FunctionComponent<ILoadBalancerActionsProps>;
+  detailsSections?: Array<FunctionComponent<ILoadBalancerDetailsSectionProps>>;
+}
+
+const getDetailsTemplate = (provider: string): Promise<IDetailsTemplateState> =>
+  Promise.all([
+    CloudProviderRegistry.getValue(provider, 'loadBalancer.useDetailsHook'),
+    CloudProviderRegistry.getValue(provider, 'loadBalancer.detailsActions'),
+    CloudProviderRegistry.getValue(provider, 'loadBalancer.detailsSections'),
+    CloudProviderRegistry.getValue(provider, 'loadBalancer.detailsTemplateUrl'),
+    CloudProviderRegistry.getValue(provider, 'loadBalancer.detailsController'),
+  ]).then(([useDetailsHook, detailsActions, detailsSections, templateUrl, detailsController]) => {
+    const detailsTemplateUrl = templateUrl ? $templateCache.get<string>(templateUrl) : undefined;
+    return {
+      useDetailsHook,
+      detailsActions,
+      detailsSections,
+      detailsTemplateUrl,
+      detailsController,
+    };
+  });
+
+function LoadBalancerDetailsWrapper({ app, loadBalancer }: ILoadBalancerDetailsWrapperProps) {
+  const { provider } = loadBalancer;
+
+  const { result: detailsTemplate } = useData<IDetailsTemplateState>(() => getDetailsTemplate(provider), {}, [
+    provider,
+  ]);
+
+  const {
+    useDetailsHook,
+    detailsActions: DetailsActions,
+    detailsSections,
+    detailsTemplateUrl,
+    detailsController,
+  } = detailsTemplate;
+
+  if (useDetailsHook && DetailsActions && detailsSections) {
+    // React rendering
+    return (
+      <LoadBalancerDetailsContent
+        app={app}
+        loadBalancer={loadBalancer}
+        useDetails={useDetailsHook}
+        Actions={DetailsActions}
+        sections={detailsSections}
+      />
+    );
+  }
+
+  if (detailsTemplateUrl && detailsController) {
+    // Angular rendering
+    return (
+      <AngularJSAdapter
+        className="detail-content flex-container-h"
+        template={detailsTemplateUrl}
+        controller={`${detailsController} as ctrl`}
+        locals={{ app, loadBalancer }}
+      />
+    );
+  }
+
+  return null;
+}
+
+export const LoadBalancerDetails = overridableComponent(LoadBalancerDetailsWrapper, 'loadBalancer.details');

package/src/loadBalancer/details/index.ts

@@ -0,0 +1,2 @@
+export * from './LoadBalancerDetails';
+export * from './LoadBalancerDetailsWrapper';

package/src/loadBalancer/index.ts

@@ -7,3 +7,4 @@ export * from './LoadBalancerClusterContainer';
 export * from './LoadBalancerInstances';
 export * from './LoadBalancerServerGroup';
 export * from './LoadBalancersTagWrapper';
+export * from './details';

package/src/loadBalancer/loadBalancer.states.ts

@@ -1,14 +1,22 @@
 import type { StateParams } from '@uirouter/angularjs';
 import { module } from 'angular';
 
-import { LoadBalancerDetails } from './LoadBalancerDetails';
 import { LoadBalancers } from './LoadBalancers';
 import type { ApplicationStateProvider } from '../application';
 import { APPLICATION_STATE_PROVIDER } from '../application';
+import { LoadBalancerDetails } from './details';
 import { filterModelConfig } from './filter/LoadBalancerFilterModel';
 import { LoadBalancerFilters } from './filter/LoadBalancerFilters';
 import type { INestedState, StateConfigProvider } from '../navigation';
 
+export interface ILoadBalancerStateParams {
+  name: string;
+  accountId: string;
+  region: string;
+  vpcId: string;
+  provider: string;
+}
+
 export const LOAD_BALANCER_STATES = 'spinnaker.core.loadBalancer.states';
 module(LOAD_BALANCER_STATES, [APPLICATION_STATE_PROVIDER]).config([
   'applicationStateProvider',
@@ -33,12 +41,13 @@ module(LOAD_BALANCER_STATES, [APPLICATION_STATE_PROVIDER]).config([
         accountId: ['$stateParams', ($stateParams: StateParams) => $stateParams.accountId],
         loadBalancer: [
           '$stateParams',
-          ($stateParams: StateParams) => {
+          ($stateParams: StateParams): ILoadBalancerStateParams => {
             return {
               name: $stateParams.name,
               accountId: $stateParams.accountId,
               region: $stateParams.region,
               vpcId: $stateParams.vpcId,
+              provider: $stateParams.provider,
             };
           },
         ],

package/src/manifest/stage/JobStageExecutionLogs.spec.tsx

@@ -0,0 +1,208 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { Subject } from 'rxjs';
+
+import { JobManifestPodLogs } from './JobManifestPodLogs';
+import { JobStageExecutionLogs } from './JobStageExecutionLogs';
+import { ManifestReader } from '../ManifestReader';
+import type { IPodNameProvider } from '../PodNameProvider';
+import type { Application } from '../../application';
+
+describe('JobStageExecutionLogs', () => {
+  const mockApplication = {} as Application;
+  const mockManifest: {
+    manifest: { metadata: { name: string; namespace: string }; spec: {}; status: {} };
+    name: string;
+    moniker: { app: string; cluster: string };
+    account: string;
+  } = {
+    account: 'test-account',
+    name: 'test-manifest',
+    moniker: {
+      app: 'testapp',
+      cluster: 'testcluster',
+    },
+    manifest: {
+      metadata: {
+        name: 'test-job',
+        namespace: 'test-namespace',
+      },
+      spec: {},
+      status: {},
+    },
+  };
+  const mockPodNamesProviders: IPodNameProvider[] = [
+    {
+      getPodName: () => 'test-pod',
+    },
+  ];
+
+  let getManifestSpy: jasmine.Spy;
+  const subject = new Subject();
+
+  beforeEach(() => {
+    getManifestSpy = spyOn(ManifestReader, 'getManifest').and.returnValue(subject);
+  });
+
+  afterEach(() => {
+    getManifestSpy.calls.reset();
+  });
+
+  it('should fetch manifest on mount', () => {
+    shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink=""
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    expect(getManifestSpy).toHaveBeenCalledWith('test-account', 'test-namespace', 'test-job');
+  });
+
+  it('should render JobManifestPodLogs when location is provided and no externalLink', () => {
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink=""
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    subject.next(mockManifest);
+    wrapper.update();
+
+    const podLogs = wrapper.find(JobManifestPodLogs);
+    expect(podLogs.exists()).toBeTruthy();
+    expect(podLogs.props()).toEqual({
+      account: 'test-account',
+      location: 'test-namespace',
+      podNamesProviders: mockPodNamesProviders,
+      linkName: 'Console Output',
+    });
+  });
+
+  it('should not render JobManifestPodLogs when location is not provided', () => {
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink=""
+        podNamesProviders={mockPodNamesProviders}
+        location=""
+      />,
+    );
+
+    subject.next(mockManifest);
+    wrapper.update();
+
+    expect(wrapper.find(JobManifestPodLogs).exists()).toBeFalsy();
+  });
+
+  it('should render external link when provided and manifest is not empty', () => {
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink="https://example.com/logs"
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    subject.next(mockManifest);
+    wrapper.update();
+
+    const link = wrapper.find('a');
+    expect(link.exists()).toBeTruthy();
+    expect(link.prop('href')).toBe('https://example.com/logs');
+    expect(link.text()).toBe('Console Output (External)');
+  });
+
+  it('should render external link with template variables', () => {
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink="https://example.com/logs/{{manifest.metadata.namespace}}/{{manifest.metadata.name}}"
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    subject.next(mockManifest);
+    wrapper.update();
+
+    const link = wrapper.find('a');
+    expect(link.exists()).toBeTruthy();
+    expect(link.prop('href')).toBe('https://example.com/logs/test-namespace/test-job');
+  });
+
+  it('should not render external link with templates when manifest is empty', () => {
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink="https://example.com/logs/{{manifest.metadata.namespace}}/{{manifest.metadata.name}}"
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    // Don't call subject.next() to simulate empty manifest state
+
+    const podLogs = wrapper.find(JobManifestPodLogs);
+    expect(podLogs.exists()).toBeTruthy();
+    expect(wrapper.find('a').exists()).toBeFalsy();
+  });
+
+  it('should not template link if it does not include template syntax', () => {
+    const externalLink = 'https://example.com/logs';
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink={externalLink}
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    subject.next(mockManifest);
+    wrapper.update();
+
+    const link = wrapper.find('a');
+    expect(link.prop('href')).toBe(externalLink);
+  });
+
+  it('should handle errors in manifest fetching gracefully', () => {
+    const wrapper = shallow(
+      <JobStageExecutionLogs
+        deployedName="test-job"
+        account="test-account"
+        application={mockApplication}
+        externalLink=""
+        podNamesProviders={mockPodNamesProviders}
+        location="test-namespace"
+      />,
+    );
+
+    // Simulate an error
+    subject.error(new Error('Failed to fetch manifest'));
+    wrapper.update();
+
+    // Component shouldn't crash and should render the JobManifestPodLogs as fallback
+    expect(wrapper.find(JobManifestPodLogs).exists()).toBeTruthy();
+  });
+});

package/src/manifest/stage/JobStageExecutionLogs.tsx

@@ -1,4 +1,4 @@
-import { template } from 'lodash';
+import { isEmpty, template } from 'lodash';
 import React from 'react';
 import { from as observableFrom, Subject } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
@@ -52,7 +52,7 @@ export class JobStageExecutionLogs extends React.Component<IJobStageExecutionLog
     const { manifest } = this.state;
     const { externalLink, podNamesProviders, location, account } = this.props;
     // prefer links to external logging platforms
-    if (externalLink) {
+    if (externalLink && (!externalLink.includes('{{') || !isEmpty(manifest))) {
       return (
         <a target="_blank" href={this.renderExternalLink(externalLink, manifest)}>
           Console Output (External)

package/src/presentation/modal/index.ts

@@ -3,3 +3,4 @@ export * from './ModalHeader';
 export * from './ModalBody';
 export * from './ModalFooter';
 export * from './showModal';
+export * from './useModal';

package/src/presentation/modal/useModal.ts

@@ -0,0 +1,45 @@
+import { useCallback, useState } from 'react';
+
+/**
+ * Custom hook to manage modal visibility.
+ * Provides methods to open and close a modal.
+ *
+ * @param {UseModalProps} [props] - Configuration options for initial modal state.
+ * @param {boolean} [props.defaultOpen=false] - Initial visibility state of the modal.
+ * @returns {UseModalReturn} - The current state and control methods for the modal.
+ */
+export type UseModalReturn = {
+  open: boolean;
+  show: () => void;
+  close: () => void;
+};
+
+/**
+ * Configuration options for the useModal hook.
+ *
+ * @typedef {Object} UseModalProps
+ * @property {boolean} [defaultOpen=false] - Initial state of the modal.
+ */
+export type UseModalProps = {
+  defaultOpen?: boolean;
+};
+
+/**
+ * Hook to control modal visibility.
+ * Returns methods to open and close a modal, and the modal's current state.
+ *
+ * @param {UseModalProps} [props] - The configuration for the modal.
+ * @returns {UseModalReturn} - Modal visibility state and control methods.
+ */
+export const useModal = ({ defaultOpen = false }: UseModalProps = {}): UseModalReturn => {
+  const [open, setOpen] = useState(defaultOpen);
+
+  const show = useCallback(() => setOpen(true), [open]);
+  const close = useCallback(() => setOpen(false), [open]);
+
+  return {
+    open,
+    show,
+    close,
+  };
+};

package/src/task/index.ts

@@ -1,6 +1,7 @@
 export * from './PlatformHealthOverrideMessage';
 export * from './monitor/TaskMonitor';
 export * from './monitor/TaskMonitorWrapper';
+export * from './monitor/useTaskMonitor';
 export * from './modal/TaskReason';
 export * from './modal/TaskMonitorModal';
 export * from './task.read.service';