1

お時間をいただきありがとうございます。SwiftでAWSTaskオブジェクトを使用する適切な方法は何ですか?

私のコードでは、AWSSQSに対して、AWSTaskを返すさまざまな要求を行っています。これらのAWSTaskオブジェクトを操作することは非常に困難であると同時に、AWS固有のすべてのロジックを単一のクラスに保ちながら、必要に応じて別のクラウドサービスに簡単に切り替えることができます。

私がやりたいことは、一連のAWSタスクを非同期的に連続的に実行することです。通常、カスタムのシリアルディスパッチキューにタスクを追加するだけですが、AWSTaskオブジェクト自体は非同期タスクなので、できません。

ここには、私が抱えている問題を示す簡単な例があります。それは実際の世界の目的を持っていませんが、問題を説明する良い仕事をしています。以下では、SQSキューを作成し、SQSキューにメッセージを送信し、SQSキューからメッセージを受信し、SQSキューを削除するコードを用意しています。私はこれらの4つのことをシリアル非同期方式でやりたいとしましょう。言い換えれば、次のタスクを試みる前に前のタスクが成功したことを確認したいと思います。

のViewController

DispatchQueue.global(qos: DispatchQoS.QoSClass.userInitiated).async { 
     awsClass.runTest() 
     DispatchQueue.main.async { 
      print("Test Finished") 
     } 
    } 

AwsClass

public func createQueue(){ 
    guard let createQueueRequest = AWSSQSCreateQueueRequest() else{fatalError()} 

    createQueueRequest.queueName = "TestQueue" 

    sqs.createQueue(createQueueRequest).continueWith(block: {(task) -> AnyObject? in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      self.queueUrl = task.result!.queueUrl! 
      print("created queue at: \(self.queueUrl!)") 
     } 
     return nil 
    }) 
} 

public func deleteQueue(){ 
    if queueUrl != nil { 
     guard let deleteQueueRequest = AWSSQSDeleteQueueRequest() else{fatalError()} 

     deleteQueueRequest.queueUrl = queueUrl 

     sqs.deleteQueue(deleteQueueRequest).continueWith(block: {(task) -> AnyObject? in 
      if task.error != nil { 
       print(task.error!) 
      } 
      else if task.result != nil { 
       print("queue sucessfully deleted from \(self.queueUrl!)") 
       self.queueUrl = nil 
      } 
      return nil 
     }) 
    } 
    else{ 
     print("Queue has already been deleted") 
    } 
} 

public func sendMessage(messageData: String, toConnectId: String) { 
    guard let sendMessageRequest = AWSSQSSendMessageRequest() else{fatalError()} 
    sendMessageRequest.queueUrl = toConnectId 
    sendMessageRequest.delaySeconds = 0 
    sendMessageRequest.messageBody = messageData 
    sqs.sendMessage(sendMessageRequest).continueWith(block: {(task) -> AnyObject? in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      print("successfully sent message to \(toConnectId)") 
     } 
     return nil 
    }) 
} 

public func receiveMessage(){ 
    guard let receiveMessageRequest = AWSSQSReceiveMessageRequest() else{fatalError()} 
    receiveMessageRequest.queueUrl = self.queueUrl 
    receiveMessageRequest.maxNumberOfMessages = 1 

    sqs.receiveMessage(receiveMessageRequest).continueWith(block: {(task) -> AnyObject? in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      let message = (task.result?.messages?.first)! 
      print("successfully received message with body: \(message.body ?? "failed")") 
     } 
     return nil 
    }) 
} 

public func runTest(){ 
    let mySerialQueue = DispatchQueue(label: "mySerialQueue") 
    mySerialQueue.sync { 
     self.createQueue() 
    } 
    mySerialQueue.sync { 
     self.sendMessage(messageData: "test", toConnectId: "https://someUrl") 
    } 
    mySerialQueue.sync { 
     self.receiveMessage() 
    } 
    mySerialQueue.sync { 
     self.deleteQueue() 
    } 
} 

AWSTasksは補完関数と非同期であるので、コードはすぐにすべての4つの呼び出しを行い、これらのタスクが完了したときに、その後の補完関数が呼び出されます。代わりに、次のタスクが始まる前に、最初のタスクの完了機能を終了します。

答えて

0

申し訳ありませんが、私は私の質問に対する解決策を見つけました。それは望みどおり正確に機能しますが、この厄介な補完機能のチェーンではそうです。より洗練されたソリューションを誰かが知っていれば、私はすべての耳です!

のViewController

print("Starting Test") 
    DispatchQueue.global(qos: DispatchQoS.QoSClass.userInitiated).async { 
     atomConnector.runTest(completion: { 
      print("test finshed") 
     }) 
    } 

AwsClass

public func createQueue(completion: @escaping() -> Void){ 
    guard let createQueueRequest = AWSSQSCreateQueueRequest() else{fatalError()} 

    createQueueRequest.queueName = "TestQueue" 

    sqs.createQueue(createQueueRequest).continueWith(block: {(task) -> Void in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      self.queueUrl = task.result!.queueUrl! 
      print("created queue at: \(self.queueUrl!)") 
      completion() 
     } 
    }) 
} 

public func deleteQueue(completion: @escaping() -> Void){ 
    if queueUrl != nil { 
     guard let deleteQueueRequest = AWSSQSDeleteQueueRequest() else{fatalError()} 

     deleteQueueRequest.queueUrl = queueUrl 

     sqs.deleteQueue(deleteQueueRequest).continueWith(block: {(task) -> Void in 
      if task.error != nil { 
       print(task.error!) 
      } 
      else if task.result != nil { 
       print("queue sucessfully deleted from \(self.queueUrl!)") 
       self.queueUrl = nil 
       completion() 
      } 
     }) 
    } 
    else{ 
     print("Queue has already been deleted") 
    } 
} 

public func sendMessage(messageData: String, toConnectId: String, completion: @escaping() -> Void) { 
    guard let sendMessageRequest = AWSSQSSendMessageRequest() else{fatalError()} 
    sendMessageRequest.queueUrl = toConnectId 
    sendMessageRequest.delaySeconds = 0 
    sendMessageRequest.messageBody = messageData 
    sqs.sendMessage(sendMessageRequest).continueWith(block: {(task) -> Void in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      print("successfully sent message to \(toConnectId)") 
      completion() 
     } 
    }) 
} 

public func receiveMessage(completion: @escaping() -> Void){ 
    guard let receiveMessageRequest = AWSSQSReceiveMessageRequest() else{fatalError()} 
    receiveMessageRequest.queueUrl = self.queueUrl 
    receiveMessageRequest.maxNumberOfMessages = 1 

    sqs.receiveMessage(receiveMessageRequest).continueWith(block: {(task) -> Void in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      let message = (task.result?.messages?.first)! 
      print("successfully received message with body: \(message.body ?? "failed")") 
      self.deleteMessage(receiptHandle: message.receiptHandle, completion: completion) 
     } 
    }) 
} 

public func deleteMessage(receiptHandle: String?, completion: @escaping() -> Void){ 
    guard let deleteMessageRequest = AWSSQSDeleteMessageRequest() else{fatalError()} 
    deleteMessageRequest.queueUrl = self.queueUrl 
    deleteMessageRequest.receiptHandle = receiptHandle 

    sqs.deleteMessage(deleteMessageRequest).continueWith(block: {(task) -> Void in 
     if task.error != nil { 
      print(task.error!) 
     } 
     else if task.result != nil { 
      print("successfully deleted message with receiptHandle: \(receiptHandle)") 
      completion() 
     } 
    }) 
} 

public func runTest(completion: @escaping() -> Void){ 

    self.createQueue(completion: { 
     self.sendMessage(messageData: "test", toConnectId: "https://someUrl", completion: { 
      self.receiveMessage(completion: { 
       self.deleteQueue(completion: { 
        completion() 
       }) 
      }) 
     }) 
    }) 

} 
1

AWSTaskオブジェクトは一緒に "連鎖" ことを意味しています。 ドキュメントはここで見つけることができます:ここhttp://docs.aws.amazon.com/mobile/sdkforios/developerguide/awstask.html

小さな例:

sqs.createQueue(/* parameters */).continueWithSuccess(block: {(task) -> Void in 
    // Success 
    return sqs.sendMessage(/* parameters */) 
}).continueWithSuccess(block: {(task) -> Void in 
    // Success 
    return sqs.receiveMessage(/* parameters */) 
}).continueWithSuccess(block: {(task) -> Void in 
    // Success 
    return sqs.deleteQueue(/* parameters */) 
}) 
関連する問題