Deprecate queue item locking and retrying

Author: nukeop

packages/app/app/actions/queue.ts

@@ -21,8 +21,6 @@ type LocalTrack = Track & {
   local: true;
 };
 
-export const streamLookupRetriesLimit = 3;
-
 const isLocalTrack = (track: Track): track is LocalTrack => track.local;
 
 const localTrackToQueueItem = (track: LocalTrack, local: LocalLibraryState): QueueItem => {
@@ -156,7 +154,6 @@ export const reloadTrack = (index: number) => async (dispatch, getState) => {
     updateQueueItem({
       ...track,
       error: false,
-      streamLookupRetries: 0,
       streams: []
     })
   );
@@ -278,17 +275,16 @@ export const findStreamsForTrack = (index: number) => async (dispatch, getState)
     }));
   } catch (e) {
     logger.error(
-      `An error has occurred when searching for streams with ${selectedStreamProvider.sourceName} for "${track.artist} - ${track.name}". Retrying...`
+      `An error has occurred when searching for streams with ${selectedStreamProvider.sourceName} for "${track.artist} - ${track.name}".`
     );
     logger.error(e);
 
     track = getLatestTrack();
     dispatch(updateQueueItem({
       ...track,
       loading: false,
-      streamLookupRetries: (track.streamLookupRetries ?? 0) + 1,
       error: {
-        message: 'Stream lookup error. Retrying...',
+        message: 'Stream lookup error.',
         details: e.message
       }
     }));

packages/app/app/components/PlayQueue/QueueItemClone/index.tsx

@@ -8,7 +8,6 @@ import { useTranslation } from 'react-i18next';
 export type QueueItemCloneProps = {
   settings: SettingsState;
   queue: QueueStore;
-  streamLookupRetriesLimit: number;
   onSelectTrack: (index: number) => () => void;
   onRemoveTrack: (index: number) => () => void;
   onReloadTrack: (index: number) => () => void;
@@ -18,7 +17,6 @@ export type QueueItemCloneProps = {
 export const QueueItemClone: (props: QueueItemCloneProps) => DraggableChildrenFn = ({
   settings,
   queue,
-  streamLookupRetriesLimit,
   onSelectTrack,
   onRemoveTrack,
   onReloadTrack,
@@ -35,8 +33,6 @@ export const QueueItemClone: (props: QueueItemCloneProps) => DraggableChildrenFn
       isCompact={settings.compactQueueBar as boolean}
       isCurrent={queue.currentTrack === rubric.source.index}
       track={queue.queueItems[rubric.source.index]}
-      streamLookupRetries={queue.queueItems[rubric.source.index].streamLookupRetries}
-      streamLookupRetriesLimit={streamLookupRetriesLimit}
       onSelect={onSelectTrack(rubric.source.index)}
       onRemove={onRemoveTrack(rubric.source.index)}
       onReload={onReloadTrack(rubric.source.index)}

packages/app/app/components/PlayQueue/index.tsx

@@ -22,7 +22,6 @@ import { StreamVerificationContainer } from '../../containers/StreamVerification
 
 import styles from './styles.scss';
 import { QueueItemClone } from './QueueItemClone';
-import { streamLookupRetriesLimit } from '../../actions/queue';
 
 type PlayQueueProps = {
   actions: PlayQueueActions;
@@ -178,8 +177,6 @@ const PlayQueue: React.FC<PlayQueueProps> = ({
                     isCurrent={data.queue.currentTrack === index}
                     track={item}
                     duration={formatTrackDuration(t)(item)}
-                    streamLookupRetries={item.streamLookupRetries}
-                    streamLookupRetriesLimit={streamLookupRetriesLimit}
                     onSelect={onSelectTrack(index)}
                     onRemove={onRemoveTrack(index)}
                     onReload={onReloadTrack(index)}
@@ -234,7 +231,6 @@ const PlayQueue: React.FC<PlayQueueProps> = ({
           renderClone={QueueItemClone({
             settings,
             queue,
-            streamLookupRetriesLimit,
             onSelectTrack,
             onRemoveTrack,
             onReloadTrack,

packages/app/app/containers/PlayerBarContainer/PlayerBarContainer.test.tsx

@@ -247,99 +247,6 @@ describe('PlayerBar container', () => {
     expect(state.queue.currentTrack).toBe(0); 
   });
 
-  xit('should lock the track after failing to resolve stream URLs after 3 retries', async () => {
-    const { store, component } = mountComponent({
-      queue: {
-        currentTrack: 0,
-        queueItems: [
-          {
-            uuid: 'uuid1',
-            artist: 'test artist name',
-            name: 'track without streams',
-            streamLookupRetries: 2
-            // no streams provided
-          }
-        ]
-      },
-      plugin: {
-        plugins: {
-          streamProviders: [
-            {
-              sourceName: 'Mocked Stream Provider',
-              search: jest.fn(() => ([{
-                id: 'test-stream-id',
-                author: {
-                  name: 'test author'
-                }
-              }])),
-              getStreamForId: jest.fn(() => {
-                throw new Error('Failed to load stream.'); 
-              })
-            }
-          ]
-        },
-        selected: {
-          streamProviders: 'Mocked Stream Provider'
-        }
-      }
-    });
-
-    await waitFor(() => {
-      const state = store.getState();
-      const track = state.queue.queueItems[0];
-      expect(track.error).toBeTruthy();
-      expect(track.streamLookupRetries).toBe(3);
-    });
-
-    const errorOverlay = await component.findByText('Failed to load stream.');
-    expect(errorOverlay).toBeInTheDocument();
-  });
-
-  xit('should increment streamLookupRetries after a stream lookup failure', async () => {
-    const { store, component } = mountComponent({
-      queue: {
-        currentTrack: 0,
-        queueItems: [
-          {
-            uuid: 'uuid1',
-            artist: 'test artist name',
-            name: 'track without streams',
-            streamLookupRetries: 0,
-            streams: []
-          }
-        ]
-      },
-      plugin: {
-        plugins: {
-          streamProviders: [
-            {
-              sourceName: 'Mocked Stream Provider',
-              search: jest.fn().mockResolvedValue(() => ([{
-                id: 'test-stream-id',
-                author: {
-                  name: 'test author'
-                }
-              }])),
-              getStreamForId: jest.fn(() => {
-                throw new Error('Failed to load stream.'); 
-              })
-            }
-          ]
-        },
-        selected: {
-          streamProviders: 'Mocked Stream Provider'
-        }
-      }
-    });
-    
-    await waitFor(() => {
-      const state = store.getState();
-      const track = state.queue.queueItems[0];
-      expect(track.streamLookupRetries).toBe(1);
-      expect(track.error).toBeTruthy();
-    });
-  });
-
   const mountComponent = (initialStore?: AnyProps) => {
     const store = configureMockStore({
       ...buildStoreState()

packages/app/app/containers/PlayerBarContainer/hooks.streamLookup.test.ts

@@ -1,6 +1,5 @@
 import { shouldSearchForStreams } from './hooks';
 import { QueueStore, QueueItem } from '../../reducers/queue';
-import { streamLookupRetriesLimit } from '../../actions/queue';
 
 describe('shouldSearchForStreams', () => {
   const createQueueStore = (items: QueueItem[]): QueueStore => ({
@@ -24,22 +23,7 @@ describe('shouldSearchForStreams', () => {
     expect(shouldSearchForStreams(queue)).toBe(false);
   });
 
-  it('returns false when an item with error has reached retries limit', () => {
-    const queue = createQueueStore([
-      { error: { message: 'error', details: 'details' }, streamLookupRetries: streamLookupRetriesLimit, artist: 'A', name: 'a' }
-    ]);
-    expect(shouldSearchForStreams(queue)).toBe(false);
-  });
-
-  it('returns true when at least one item has no stream and has not reached retries limit', () => {
-    const queue = createQueueStore([
-      { streams: [{ id: '1', source: '1', stream: 'http://test' }], artist: 'A', name: 'a' },
-      { error: { message: 'error', details: 'details' }, streamLookupRetries: streamLookupRetriesLimit - 1, artist: 'B', name: 'b' }
-    ]);
-    expect(shouldSearchForStreams(queue)).toBe(true);
-  });
-
-  it('returns true when at least one item has no stream and no error/retries info', () => {
+  it('returns true when at least one item has no stream and no error info', () => {
     const queue = createQueueStore([
       { streams: [], artist: 'A', name: 'a' }
     ]);

packages/app/app/containers/PlayerBarContainer/hooks.ts

@@ -19,7 +19,6 @@ import { playerSelectors } from '../../selectors/player';
 import { queue as queueSelector } from '../../selectors/queue';
 import { settingsSelector } from '../../selectors/settings';
 import { QueueItem, QueueStore } from '../../reducers/queue';
-import { streamLookupRetriesLimit } from '../../actions/queue';
 
 export const useSeekbarProps = () => {
   const dispatch = useDispatch();
@@ -268,8 +267,7 @@ export const useStreamLookup = () => {
     if (
       currentTrack &&
       !currentTrack.loading &&
-      queueActions.trackHasNoFirstStream(currentTrack) &&
-      (currentTrack.streamLookupRetries === undefined || currentTrack.streamLookupRetries < 3)
+      queueActions.trackHasNoFirstStream(currentTrack)
     ) {
       dispatch(queueActions.findStreamsForTrack(queue.currentTrack));
       return;
@@ -280,8 +278,7 @@ export const useStreamLookup = () => {
       const nextTrackWithNoStream = queue.queueItems.findIndex((item, index) => 
         index !== queue.currentTrack &&
         !item.loading && 
-        isEmpty(item.streams) && 
-        (item.streamLookupRetries < streamLookupRetriesLimit || item.streamLookupRetries === undefined)
+        isEmpty(item.streams)
       );
 
       if (nextTrackWithNoStream !== -1) {
@@ -294,7 +291,6 @@ export const useStreamLookup = () => {
 export const shouldSearchForStreams = (queue: QueueStore): boolean => {
   return queue.queueItems.length > 0 && !queue.queueItems.every(item => 
     item.local || 
-    (item.streams?.[0]?.stream) ||
-    (item.error && item.streamLookupRetries !== undefined && item.streamLookupRetries >= streamLookupRetriesLimit)
+    (item.streams?.[0]?.stream)
   );
 };

packages/app/app/reducers/queue.ts

@@ -27,7 +27,6 @@ export type QueueItem = {
         message: string;
         details: string;
       };
-  streamLookupRetries?: number;
   local?: boolean;
   artist: string | { name: string };
   name: string;

packages/ui/lib/components/QueueItem/index.tsx

@@ -21,8 +21,6 @@ export type QueueItemProps = {
   isCompact: boolean;
   track: Track;
   duration: string;
-  streamLookupRetries: number;
-  streamLookupRetriesLimit: number;
   onSelect: () => void;
   onRemove: () => void;
   onReload: () => void;
@@ -38,27 +36,21 @@ export const QueueItem: React.FC<QueueItemProps> = ({
   isCompact,
   track,
   duration,
-  streamLookupRetries,
-  streamLookupRetriesLimit,
   onRemove,
   onSelect,
   onReload,
   strings
 }) => {
-  const isLocked = streamLookupRetries >= streamLookupRetriesLimit;
-
   return (
     <div
       className={cx(
         common.nuclear,
         styles.queue_item,
         { [`${styles.current_track}`]: isCurrent },
         { [`${styles.error}`]: Boolean(track.error) },
-        { [`${styles.locked}`]: isLocked },
         { [`${styles.compact}`]: isCompact }
       )}
       onDoubleClick={onSelect}
-      onClick={isLocked && onReload}
     >
       <div className={styles.thumbnail}>
         {
@@ -67,14 +59,7 @@ export const QueueItem: React.FC<QueueItemProps> = ({
         }
 
         {
-          isLocked && 
-          <div className={styles.lock}>
-            <Icon name='lock' size={isCompact ? 'small' : 'big'} className={styles.lock_icon} />
-          </div>
-        }
-
-        {
-          !track.loading && !isLocked &&
+          !track.loading &&
           <Img               
             src={getThumbnail(track) ?? artPlaceholder}
             unloader={<img src={artPlaceholder}/>}
@@ -95,7 +80,7 @@ export const QueueItem: React.FC<QueueItemProps> = ({
       </div>
 
       {
-        !track.error && !isLocked && !isCompact &&
+        !track.error && !isCompact &&
         <>
           <div className={styles.item_info_container}>
             <div className={styles.name_container}>
@@ -108,7 +93,6 @@ export const QueueItem: React.FC<QueueItemProps> = ({
 
           {
             !track.loading &&
-            !isLocked &&
               !isEmpty(track.streams) &&
               <div className={styles.item_duration_container}>
                 <div className={styles.item_duration}>
@@ -126,7 +110,7 @@ export const QueueItem: React.FC<QueueItemProps> = ({
       }
 
       {
-        isLocked && !isCompact &&
+        !isCompact &&
         <div className={styles.error_overlay}>
           <div className={styles.error_message}>
             {strings.locked}

packages/ui/stories/components/queueItem.stories.tsx

@@ -27,8 +27,6 @@ const commonProps = {
   onReload: () => {
     alert('Item reloaded');
   },
-  streamLookupRetries: 0,
-  streamLookupRetriesLimit: 3,
   strings: {
     locked: 'Stream lookup failed. Click to start over.'
   }
@@ -97,14 +95,6 @@ export const Compact = () => (
       <QueueItem {...commonProps} isCompact 
         track={{...commonProps.track, error: { message: 'An error has occurred.', details: 'Error details are available here.' }}}
       />
-      <QueueItem
-        {...commonProps}
-        isCompact
-        track={{...commonProps.track
-        }}
-        streamLookupRetries={3}
-        streamLookupRetriesLimit={3}
-      />
     </div>
   </div>
 );
@@ -141,14 +131,3 @@ export const Error = () => (
     />
   </div>
 );
-
-export const Locked = () => (
-  <div className='bg'>
-    <QueueItem {...commonProps}
-      track={{...commonProps.track
-      }}
-      streamLookupRetries={3}
-      streamLookupRetriesLimit={3}
-    />
-  </div>
-);