return Observable.create(o => {
      const disposables = new Subscription()
      log.debug(
        `Subscribing to topic [${topic}]. Is connected [${this.isConnected}]`
      )

      if (!this.isConnected) {
        o.error(
          new Error(
            `Session not connected, can\'t subscribe to topic [${topic}]`
          )
        )
        return disposables
      }

      let subscription
      this.autobahn.session
        .subscribe(topic, (response: Array<any>) => {
          this.logResponse(topic, response)
          o.next(response[0])
        })
        .then(
          sub => {
            // subscription succeeded, subscription is an instance of autobahn.Subscription
            log.verbose(`subscription acked on topic [${topic}]`)
            subscription = sub
          },
          (error: Error) => {
            // subscription failed, error is an instance of autobahn.Error
            log.error(`Error on topic ${topic}`, error)
            o.error(error)
          }
        )

      disposables.add(
        new Subscription(() => {
          if (!subscription) {
            return
          }
          try {
            this.autobahn.session
              .unsubscribe(subscription)
              .then(
                gone =>
                  log.verbose(`Successfully unsubscribing from topic ${topic}`),
                err => log.error(`Error unsubscribing from topic ${topic}`, err)
              )
          } catch (err) {
            log.error(`Error thrown unsubscribing from topic ${topic}`, err)
          }
        })
      )
      return disposables
    })

 ngOnDestroy()
 {
    const me = this.constructor.name + '.ngOnDestroy(): ';
    console.log( me);
    if (this._currentClusterSubscription)
       this._currentClusterSubscription.unsubscribe();
 }

 this.taskListService.getUserLists().subscribe((taskListsObservable) => {
   if (this.taskListsSubscription != null) {
     this.taskListsSubscription.unsubscribe();
   }
   this.taskListsSubscription =
       taskListsObservable.subscribe((taskLists) => { this.taskLists = taskLists; });
 });

  private removePreLoader() {
    if(document) {
      let $body = document.body;
      let preloader = document.getElementById('preloader');
      if(preloader) {
        $body.removeChild(preloader);
        this.routeEventsSubscription.unsubscribe();
      }
      $body.classList.remove('loading');

    }
  }

  add(teardownSrc: TeardownLogic): Subscription {
    let teardown: any = teardownSrc
    if (this.closed) return this
    if (typeof(teardownSrc) === 'function') teardown = new Subscription(teardown)

    if (this.currentSubscription) {
      this.remove(this.currentSubscription)
      this.currentSubscription.unsubscribe()
      this.currentSubscription = null
    }

    super.add(this.currentSubscription = teardown)
    return this
  }

 runPreIFrameTasks() {
     if (this._preIFrameTasks && this._preIFrameTasks.isUnsubscribed) {
         this._preIFrameTasks.unsubscribe();
     }
     this._preIFrameTasks = Observable.timer(0, 60000)
         .concatMap<string>(() => this._http.get('api/token?plaintext=true').retry(5).map<string>(r => r.text()))
         .subscribe(t => this._userService.setToken(t));
 }

 (navTabName: string) => {
     if( navTabName !== name && !this.vhostTreeSubs.isUnsubscribed ) { // 플레이어 탭이 아닐 때
         this.vhostTreeSubs.unsubscribe();
         this.stopAllPlayers();
     }
     else {
         this.subscribeVhostTree();
         this.reloadAllPlayers();
     }
 }

                setTimeout(() => {
                    if (value.indexOf("/") !== -1) {
                        o.next({ noSlashAsync: true });
                    } else {
                        o.next(null);
                    }

                    // wait for bug update. maybe at final release.
                    console.log(v);

                    o.complete();
                    s.unsubscribe();
                }, 1000);

 .subscribe(limitCheckResult => {
   if (limitCheckResult) {
     const request = serviceClient
       .createRequestResponseOperation(
         'executeTrade',
         executeTradeRequest
       )
       .publish()
       .refCount()
     disposables.add(
       Observable.merge(
         request
           .map(dto => {
             const trade = tradeMapper.mapFromTradeDto(dto.Trade)
             log.info(
               `execute response received for: ${executeTradeRequest}. Status: ${trade.status}`,
               dto
             )
             return createExecuteTradeResponse(trade)
           })
           // if we never receive a response, mark request as complete
           .timeout(
             EXECUTION_REQUEST_TIMEOUT_MS,
             Scheduler.asap.schedule(() =>
               createExecuteTradeResponseForError(
                 'Trade execution timeout exceeded',
                 executeTradeRequest
               )
             )
           ),
         // show timeout error if request is taking longer than expected
         Observable.timer(EXECUTION_CLIENT_TIMEOUT_MS)
           .map(() =>
             createExecuteTradeResponseForError(
               'Trade execution timeout exceeded',
               executeTradeRequest
             )
           )
           .takeUntil(request)
       ).subscribe(o)
     )
   } else {
     o.next(
       createExecuteTradeResponseForError(
         'Credit limit exceeded',
         executeTradeRequest
       )
     )
   }
 })