최근, 혼자 쏘캐너를 만들고 있었습니다. Android, iOS 둘 다 만들어서 마켓에 런칭한 이 후 Anil 이라는 좋은 인도 개발자를 만나서 안드로이드쪽은 떼 주고 이전에 정리했었던 기술도 어느 정도 통일이 되어 Swift + SwiftUI 로 최신 프로젝트를 하고 있습니다. 제가 기여한 오픈소스를 가져와서 프로그램을 만들기 때문에 회사 귀속으로 할 수도 없거니와(하려면 해당 오픈 소스들을 제 값주고 다 사야 하는데 아마 수천억 들겠죠) 제가 인터넷에서 받은 수 많은 지식들을 회사 귀속 코드를 제외하고 다 돌려 드리기 위해 이 카테고리를 만들었습니다. 어찌보면 광고의 목적도 있고, 함께 하고픈 사람도 계속 늘여 나가고 싶기도 하구요. IPO가 목적인데, 처음엔 일부 동의하는 사람이 있는 줄 알았는데 지금보니 저 혼자 IPO를 믿고 있는 것 같습니다. 아마 기술 분야로 해야 하고 마지막 그림은 저 외엔 보기 힘들다는 점도 ... 이걸 깨달아야 외롭지 않게 묵묵히 길을 갈 수 있겠지요. 이 블로그를 살아 움직입니다. 글이 써졌다가 고쳐졌다가 지워지기도 하구요. 아마 오랜 구독자는 이미 잘 알고 계시리라 생각합니다. 단, 거짓말은 하지 않는 다는 것을요. 순수한 마음으로 접근해도 평생을 바쳐도 모자란 것이 지식 탐구라는 것을 알면, 세속적 기준을 가져다 대는 것이 얼마나 우스운 일인지... 10대 때 알았던 사람은 저처럼 40대가 되어도 변함이 없다는 것을, 또 80대가 되어도 마찬가지라는 것을 알겁니다.
요즘은 거의 백엔드만 하고 있어서 사실 iOS도 적합한 개발자를 뽑으면 이 카테고리도 shutting down 하고 백엔드에만 집중하고 싶습니다. 그래도 iOS 개발이 10년이 넘어가다 보니 Xcode 단축키만 쳐도 뭔가 편안함이 느껴지는 터라.
취미로 개발을 하고,
취미로 개발을 해도 publishing 이 가능한 분야가 되었네요.
이에, 꾸준히 빌드업을 할테고 백엔드를 해서인지 다른 언어를 통해 Swift 를 보는 관점을 달리 해 보니 또 더 깊게 알게 되는 것 같아 좋아요. 지난 게시글이 있지만 #This Document continuously updated. 라는 문구가 있으면 지난 자료는 뒤로 보내거나 없애거나 수정을 하며 하나의 게시글을 계속 업데이트 하는 방식으로 진행하려고 합니다. 그래서 아무리 시간이 지나도(제가 죽을 때까지?) 한 카테고리 당 100개의 게시물을 넘지 않도록 하려고 해요. 제가 60계 치킨을 좋아하다보니 그 숫자를 60에 맞추려고 할지도 모르겠군요. 아무튼, 여러개를 올리는 것 보다 좀 더 농도 짙은 게시글로 하고 싶은 마음이 있습니다. --> 테마를 바꾸어 보니 30개에 맞춰야 보기 편하겠네요.
We noticed one or more issues with a recent submission for App Store review for the following app: ---
---
--- Although submission for App Store review was successful, you may want to correct the following issues in your next submission for App Store review. Once you've corrected the issues, upload a new binary to App Store Connect.
ITMS-91053: Missing API declaration - Your app’s code in the “App” file references one or more APIs that require reasons, including the following API categories: NSPrivacyAccessedAPICategoryDiskSpace. While no action is required at this time, starting May 1, 2024, when you upload a new app or app update, you must include a NSPrivacyAccessedAPITypes array in your app’s privacy manifest to provide approved reasons for these APIs used by your app’s code. For more details about this policy, including a list of required reason APIs and approved reasons for usage, visit: https://developer.apple.com/documentation/bundleresources/privacy_manifest_files/describing_use_of_required_reason_api.
ITMS-91053: Missing API declaration - Your app’s code in the “App” file references one or more APIs that require reasons, including the following API categories: NSPrivacyAccessedAPICategoryFileTimestamp. While no action is required at this time, starting May 1, 2024, when you upload a new app or app update, you must include a NSPrivacyAccessedAPITypes array in your app’s privacy manifest to provide approved reasons for these APIs used by your app’s code. For more details about this policy, including a list of required reason APIs and approved reasons for usage, visit: https://developer.apple.com/documentation/bundleresources/privacy_manifest_files/describing_use_of_required_reason_api.
ITMS-91053: Missing API declaration - Your app’s code in the “App” file references one or more APIs that require reasons, including the following API categories: NSPrivacyAccessedAPICategoryUserDefaults. While no action is required at this time, starting May 1, 2024, when you upload a new app or app update, you must include a NSPrivacyAccessedAPITypes array in your app’s privacy manifest to provide approved reasons for these APIs used by your app’s code. For more details about this policy, including a list of required reason APIs and approved reasons for usage, visit: https://developer.apple.com/documentation/bundleresources/privacy_manifest_files/describing_use_of_required_reason_api.
TLS(전송 계층 보안)를 지원하는 FTP 서버를 설정하여 데이터 전송 중 보안을 강화할 수 있습니다. 여기서는 vsftpd를 예로 들어 TLS 지원을 추가하는 방법을 설명하겠습니다. TLS를 활성화하면 FTPS(File Transfer Protocol Secure)를 통해 데이터를 암호화하여 전송할 수 있습니다.
1. SSL 인증서 생성
FTPS 연결을 위해서는 SSL 인증서가 필요합니다. 자체 서명된(셀프 사인드) 인증서를 생성하거나, 인증 기관(CA)으로부터 인증서를 구입할 수 있습니다. 빠른 설정을 위해 여기서는 자체 서명된 인증서를 생성하는 방법을 안내합니다.
이 설정은 TLS를 활성화하고, 익명의 SSL 연결은 허용하지 않으며, 모든 로컬 데이터 전송과 로그인을 SSL을 통해 강제로 실행하도록 합니다. 또한, SSLv2와 SSLv3는 보안상의 이유로 비활성화하고, TLSv1은 활성화합니다.
3. vsftpd 재시작
설정을 변경한 후, vsftpd를 재시작하여 변경 사항을 적용합니다.
sudo systemctl restart vsftpd
4. 방화벽 설정 (필요한 경우)
TLS를 사용하는 FTP 서버는 일반적으로 제어 연결에 21번 포트를 사용하며, 데이터 전송을 위해 추가 포트를 동적으로 할당합니다. vsftpd 설정에서 pasv_min_port와 pasv_max_port를 설정하여 패시브 모드에서 사용할 포트 범위를 지정할 수 있습니다. 이 포트 범위도 방화벽을 통해 열어야 합니다.
예를 들어, 40000에서 50000 사이의 포트를 열려면:
sudo ufw allow 40000:50000/tcp
sudo ufw reload
주의사항
자체 서명된 인증서를 사용할 경우, 클라이언트는 서버의 인증서를 신뢰할지 여부를 확인할 수 있어야 합니다. 인증 기관에서 발급받은 인증서를 사용하는 것이 보다 안전하고 신뢰성이 높습니다.
FTPS와 SFTP는 서로 다릅니다. FTPS는 FTP에 SSL/TLS 보안을 추가한 것이고, SFTP는 SSH(File Transfer Protocol over SSH)를 기반으로 합니다. 용도에 맞게 적절한 프로토콜을 선택하세요.
특정 사용자가 FTP로만 접속할 수 있고 SSH로는 접속할 수 없도록 설정하는 것은 보안을 강화하는 데 도움이 될 수 있습니다. 이를 구현하는 방법은 여러 가지가 있지만, 여기서는 가장 일반적인 두 가지 방법을 소개하겠습니다.
1. 사용자 쉘을 변경하여 SSH 접속 차단
사용자의 로그인 쉘을 /bin/false나 /usr/sbin/nologin으로 변경하면 해당 사용자의 SSH 접속을 차단할 수 있습니다. 이 방법은 사용자가 시스템에 로그인할 수 없게 하지만, 사용자가 FTP를 통해 파일 전송은 가능하게 합니다. 이를 위해 다음 명령어를 사용할 수 있습니다:
sudo usermod -s /usr/sbin/nologin username
여기서 username은 해당 설정을 적용하고자 하는 사용자의 이름입니다. 이 변경 후에는 사용자가 SSH로 접속을 시도하면 접속이 거부됩니다.
2. SSH 서버 설정 변경
/etc/ssh/sshd_config 파일을 편집하여 특정 사용자 또는 사용자 그룹의 SSH 접속을 차단할 수 있습니다. 이 파일에서 DenyUsers 또는 AllowUsers 지시어를 사용하여 특정 사용자의 접속을 제어할 수 있습니다.
예를 들어, 특정 사용자 username의 SSH 접속을 차단하려면, /etc/ssh/sshd_config 파일을 열고 다음 줄을 추가합니다:
DenyUsers username
또는, 특정 사용자만 SSH 접속을 허용하고 나머지는 모두 차단하려면, AllowUsers 지시어를 사용할 수 있습니다. 이 경우, AllowUsers에 지정되지 않은 모든 사용자는 SSH 접속이 거부됩니다.
변경 후에는 SSH 서비스를 재시작하여 변경 사항을 적용해야 합니다:
sudo systemctl restart sshd
주의사항
FTP 접속만 허용하려는 경우, 보안을 위해 가능하다면 FTP 대신 SFTP(SSH File Transfer Protocol) 사용을 고려해 보세요. SFTP는 SSH를 기반으로 하므로 데이터 전송 중 암호화를 제공합니다. 위에서 설명한 방법으로 사용자의 SSH 쉘 접근을 차단하면서도, 적절히 설정된 SFTP를 통해 안전하게 파일 전송을 허용할 수 있습니다.
사용자가 시스템에 접속할 수 없도록 하면서도 FTP 또는 SFTP 접속을 허용하려면, FTP 서버나 SFTP 서버 설정에 따라 다를 수 있으므로 해당 서버의 문서나 설정 가이드를 참고하는 것이 좋습니다. FTP 서비스를 제공하는 서버 소프트웨어(예: vsftpd, ProFTPD 등)마다 설정 방법이 다를 수 있습니다.
vsftpd를 사용할 때 nologin 쉘을 가진 사용자가 FTP를 통해 로그인할 수 있도록 하기 위해 PAM 설정을 수정하는 방법을 설명하겠습니다. 기본적으로 vsftpd는 /etc/pam.d/vsftpd 파일을 통해 PAM 인증을 관리합니다. 이 파일을 수정하여 nologin 쉘을 가진 사용자도 FTP 접속을 허용할 수 있습니다.
PAM 설정 수정하기
PAM 설정 파일 열기
sudo nano /etc/pam.d/vsftpd
/etc/pam.d/vsftpd 파일을 텍스트 에디터로 엽니다. sudo 권한이 필요할 수 있습니다.
nologin 사용자 허용 설정 추가
auth required pam_shells.so
이 라인을 주석 처리하거나 삭제하여, pam_shells.so 모듈이 로그인을 시도하는 사용자의 쉘을 체크하지 않도록 할 수 있습니다. 대신, 다음과 같은 설정을 사용할 수 있습니다.pam_permit.so 모듈은 모든 인증 요청을 허용합니다. 이 설정을 사용하면 쉘 로그인이 제한된 사용자도 FTP를 통해 로그인할 수 있습니다.
auth required pam_permit.so
파일 내에서, 인증 절차를 관리하는 부분을 찾습니다. 그리고 다음 라인을 파일에 추가하거나 기존 라인을 이 내용으로 대체합니다.
파일 저장 및 종료
변경사항을 저장하고 텍스트 에디터를 종료합니다. nano를 사용하는 경우, Ctrl + O, Enter를 눌러 저장하고, Ctrl + X로 종료합니다.
vsftpd 재시작
sudo systemctl restart vsftpd
변경사항을 적용하기 위해 vsftpd를 재시작합니다.
이제 nologin 쉘을 가진 사용자도 FTP를 통해 로그인할 수 있게 됩니다. 하지만, 보안상의 이유로 이 방법을 사용할 때는 주의가 필요합니다. pam_permit.so를 사용하면 인증 과정에서 보안이 약화될 수 있으므로, 가능하다면 보다 안전한 방법을 모색하는 것이 좋습니다.
지난해 10월부터 시작된 보안 유지 노력은, 마케팅 활동이든 기업 간 협력이든 그 목적을 불문하고, 상당한 시간 동안 지속되어 왔습니다. 관련자가 점차 늘어나면서, 기술 정보의 유출을 완전히 차단하기는 어려운 실정입니다.(개인적으로 어떤 솔루션을 썼는지도 초기 보안에 중요하고, 그 부분은 지켜진 것 같음. 이제 기술 감사나 협업, 마케팅을 위해서 어쩔 수 없고 OCR 하는 타 기업과 미팅 때문에 첫 번째 성벽은 이미 무너진 걸로...)
구글이 document AI를 적극적으로 업데이트 하는 가운데, 인터넷으로부터 많은 도움을 받는 저로서는 관련 분야에서 고군분투하는 엔지니어들에게 작은 도움이라도 제공하고자 이 페이지를 마련했습니다. 가치 있는 로그와 이에 대한 해결 방안을 공유하고자 하니, 도움을 주실 분들의 댓글도 언제나 환영합니다.
실제로 카카오, 네이버와 같은 대기업이 기술 블로그를 운영하며 기술 홍보에 나서는 것처럼, 이 또한 우리 솔루션을 알리기 위한 목적 중 하나입니다.
1007)'))) An error occurred: HTTPSConnectionPool(host='oauth2.googleapis.com', port=443): Max retries exceeded with url: /token (Caused by SSLError(SSLEOFError(8, '[SSL: UNEXPECTED_EOF_WHILE_READING] EOF occurred in violation of protocol (_ssl.c:1007)'))) An error occurred: 400 Request contains an invalid argument. [field_violations { field: "raw_document.content" description: "Document size (34381195) exceeds the limit: 20971520." } ] An error occurred: HTTPSConnectionPool(host='oauth2.googleapis.com', port=443): Max retries exceeded with url: /token (Caused by SSLError(SSLEOFError(8, '[SSL: UNEXPECTED_EOF_WHILE_READING] EOF occurred in violation of protocol (_ssl.c:1007)'))) An error occurred: HTTPSConnectionPool(host='oauth2.googleapis.com', port=443): Max retries exceeded with url: /token (Caused by SSLError(SSLEOFError(8, '[SSL: UNEXPECTED_EOF_WHILE_READING] EOF occurred in violation of protocol (_ssl.c:1007)'))) An error occurred: 400 Request contains an invalid argument. [field_violations { field: "raw_document.content" description: "Document size (33770199) exceeds the limit: 20971520." } ]
또한, OCR에 영향을 주지 않으면서 파일 크기를 줄이기 위해 사용한 특정 솔루션에 대해 설명하기는 어렵지만, AI 모델 개발과 관련된 작업은 전문 담당자가 있으며, 직접 실험하거나 상당한 비용을 지출한 바가 없어 상세한 공개가 어려운 점 양해 부탁드립니다.
Dev Containers, AWS Toolkit - Amazon Q, CodeWhisperer, and more, Big Data File Viewer, Space, Big Data Tools Core, Korean Language Pack / 한국어 언어 팩, Remote File Systems, Xcode Keymap
OpenAI와 같은 기업은 보안 및 기술적인 이유로 자신들의 서버 구성과 하드웨어 세부 정보를 공개하지 않는 경우가 많습니다. 이러한 정보를 공개하면 해커나 악의적인 공격자에게 시스템에 대한 더 많은 정보를 제공하게 되어 보안 위협이 높아질 수 있습니다. 또한, 업데이트 및 변경 사항을 비밀로 유지하면 시스템을 보호하고 안정성을 유지하기 더 쉽습니다.
또한 회사의 기밀 정보나 경쟁력을 보호하기 위해서도 서버 구성 및 하드웨어 정보를 공개하지 않을 수 있습니다. 이러한 정보를 다른 경쟁 업체나 조직에 제공하지 않고 보호함으로써 경쟁 우위를 유지할 수 있습니다.
요약하면, 보안 및 기술적인 이유로 많은 기업은 서버 구성 및 하드웨어 세부 정보를 공개하지 않습니다.
runBlocking과 async는 Kotlin의 코루틴을 사용하는 두 가지 다른 구문입니다. 각각의 목적과 사용 방법에 대해 알아보겠습니다.
runBlocking:
목적: runBlocking은 주로 비동기 코드를 동기적으로 실행하는 데 사용됩니다. 일반적으로 최상위 레벨에서 사용되는 것이 아니라, 테스트 코드나 메인 함수와 같이 코루틴이 루트 수준에서 시작되는 곳에서 사용됩니다.
동작: runBlocking 블록 안에서의 모든 코루틴이 완료될 때까지 현재 스레드를 차단합니다. 따라서 일반적으로 메인 스레드에서 사용하는 것은 피해야 합니다.
예시:
runBlocking { // 코루틴 코드 }
kotlinCopy code
async:
목적: async는 비동기적으로 작업을 수행하고 그 결과를 반환하는 데 사용됩니다. 여러 async 작업을 시작하면서 각 작업의 결과를 기다리는 데 유용합니다.
동작: async는 비동기적으로 실행되며, await 함수를 통해 해당 작업이 완료될 때까지 대기할 수 있습니다.
예시:
kotlinCopy code
runBlocking { val result1 = async { // 비동기 작업 1 }val result2 = async { // 비동기 작업 2 }// result1.await()와 result2.await()를 사용하여 각 작업의 결과를 기다릴 수 있음 }
async는 주로 여러 작업을 동시에 시작하고 결과를 모아야 하는 경우에 사용됩니다. 비동기적으로 실행되기 때문에 여러 작업을 동시에 수행할 수 있습니다.
주의할 점은 runBlocking은 주로 테스트나 메인 함수와 같은 특정 상황에서만 사용되어야 하며, 메인 스레드에서의 사용은 피해야 합니다. 반면에 async는 비동기적인 작업을 수행하고 결과를 모을 때 주로 사용됩니다.
Swift에서 runBlocking 함수는 Kotlin의 runBlocking과는 다르게 내장된 함수로 제공되지 않습니다. 그러나 비슷한 기능을 구현하려면 Swift에서는 DispatchGroup을 사용하거나 async/await 패턴을 활용할 수 있습니다.
DispatchGroup 사용:
swiftCopy code
import Foundation let dispatchGroup =DispatchGroup() dispatchGroup.enter() someAsyncFunction { // 비동기 작업 완료 시 호출 dispatchGroup.leave() } dispatchGroup.enter() anotherAsyncFunction { // 다른 비동기 작업 완료 시 호출 dispatchGroup.leave() } // 모든 비동기 작업이 완료될 때까지 기다림 dispatchGroup.wait() // 여기로 오면 모든 비동기 작업이 완료된 후
DispatchGroup은 여러 비동기 작업이 완료될 때까지 기다리는 데 사용됩니다. 아래는 DispatchGroup을 사용하여 비동기 작업이 모두 완료될 때까지 기다리는 예제입니다.
async/await 사용:
swiftCopy code
funcsomeAsyncFunction() async { // 비동기 작업 수행 } funcanotherAsyncFunction() async { // 다른 비동기 작업 수행 } // 비동기 작업이 모두 완료될 때까지 기다림awaitTask.whenAll { await someAsyncFunction() await anotherAsyncFunction() } // 여기로 오면 모든 비동기 작업이 완료된 후
이것은 async/await를 사용하여 비동기 작업이 완료될 때까지 기다리는 더 간결한 방법입니다.
Swift 5.5부터는 async/await 패턴이 도입되었습니다. 이를 사용하면 비동기 코드를 더 간결하게 작성할 수 있습니다.
이러한 패턴은 Swift에서 runBlocking과 유사한 기능을 제공하며, 비동기 코드를 처리하는 데 사용됩니다. 선택적으로 Task를 사용하여 새로운 비동기 작업을 만들 수 있습니다.
SwiftUI에서는 비동기 작업 및 다중 스레딩과 관련된 개념이 있습니다. 비동기적인 코드를 작성하거나 다중 스레딩 환경에서 작업을 처리해야 하는 경우, SwiftUI 앱에서 사용할 수 있는 몇 가지 개념과 구성 요소가 있습니다.
Swift의 비동기 프로그래밍:
SwiftUI는 Swift 언어를 기반으로 하기 때문에, Swift의 비동기 프로그래밍 기능을 활용할 수 있습니다. Swift 5.5부터는 async/await와 같은 비동기적인 기능들이 도입되었습니다. 이를 통해 비동기 코드를 더 쉽게 작성하고 관리할 수 있습니다.
Combine 프레임워크:
Combine은 SwiftUI와 함께 사용되는 반응형 프로그래밍을 위한 Apple의 프레임워크입니다. 비동기적인 이벤트 스트림을 처리하고 결합하는 데 사용됩니다. Publisher 및 Subscriber와 같은 개념을 제공하여 데이터의 비동기적인 흐름을 효율적으로 다룰 수 있습니다.
SwiftUI에서는 @State 및 @Binding 속성을 사용하여 뷰의 상태를 관리합니다. 이러한 속성은 특정 값이 변경될 때 해당 뷰를 다시 그리도록 트리거됩니다. 비동기 작업이 완료된 후 뷰를 업데이트하려면 DispatchQueue.main.async 또는 Task를 사용할 수 있습니다.
swiftCopy code
Task { let result =await fetchData() DispatchQueue.main.async { self.data = result } }
위의 코드는 비동기 작업을 수행하고, 작업이 완료된 후에 메인 스레드에서 SwiftUI 뷰의 상태를 업데이트하는 예시입니다. 여기서 Task는 Swift의 새로운 비동기 작업을 나타내는 개념입니다.
SwiftUI 및 Swift의 최신 버전에서는 비동기 및 다중 스레딩을 다루기 위한 다양한 기능과 패턴이 계속해서 발전하고 있으므로, 현재의 문법과 패턴에 대한 최신 정보를 확인하는 것이 좋습니다.
If the list of SSH keys on GitHub is short and you're unsure which one is the correct key, you can try the following approach to identify the correct key:
List all SSH keys on your system: Use the ls command to list all the SSH keys in your ~/.ssh directory:
ls -al ~/.ssh
Identify the public keys: Look for files with the .pub extension in the ~/.ssh directory. These are your SSH public keys. Use cat command to view the content of each public key:
cat ~/.ssh/id_rsa.pub
Check GitHub SSH keys:
Go to your GitHub account settings.
Navigate to the "SSH and GPG keys" section.
You'll see a list of SSH keys associated with your GitHub account.
Examine the list to see if any of the keys match the ones you have locally.
Compare SSH key fingerprints: Each SSH key has a unique fingerprint. You can generate the fingerprint for each local SSH key and compare it with the fingerprints shown on GitHub to identify the matching key.This command will display the fingerprint of your SSH key. Compare this fingerprint with the fingerprints listed on GitHub.
ssh-keygen -lf ~/.ssh/id_rsa.pub
By comparing the content and fingerprints of each SSH key, you should be able to identify the correct key that matches the one listed on GitHub. Once you've identified the correct key, you can manage your keys accordingly.
종국에 보면, 솔루션에 대한 책임을 지지 않으면서 소스 때문에 키 달라는 개발자들이 많아(2명 이상)서 키 이름은 똑같이 블러핑하고 실제 repo는 다 다르게 해뒀는데, 나중에 내가 햇갈려서 말이지. LF 옵션 알아두려고. 라이어들... 뻑. 이라고 외워둬야 겠다. 리포도 더 이상 업데이트 없는 fake 리포로 해둬도 관심도 없다. 언젠가 퇴사할 때 pull 한 번 땡기고 가야지 라는게 눈에 선함. 구글은 안드로이드 소스 다 오픈해뒀고 커널 소스는 만들려면 1조는 넘게 걸리는데 다 오픈 해둬도 못 쓰는데. Open source contributor가 우대 받는게 그런 이유다.
+---------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=======================================================================================| | No running processes found | +---------------------------------------------------------------------------------------+
No VM guests are running outdated hypervisor (qemu) binaries on this host.
2024-02-27 12:05:23.171291: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`. 2024-02-27 12:05:23.210348: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered 2024-02-27 12:05:23.210387: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered 2024-02-27 12:05:23.211358: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered 2024-02-27 12:05:23.216942: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations. To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags. 2024-02-27 12:05:23.887488: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT 2024-02-27 12:05:24.625931: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22011 MB memory: -> device: 0, name: NVIDIA RTX A5000, pci bus id: 0000:3b:00.0, compute capability: 8.6 2024-02-27 12:05:27.358066: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8907 1/1 [==============================] - 2s 2s/step 1/1 [==============================] - 0s 38ms/step Time taken for predicting 32 images: 0.10529780387878418 seconds
LogBlueprint: Error: [Compiler] In use pin <Unnamed> no longer exists on node Reset Orientation and Position . Please refresh node or break links to remove pin. from Source: /Game/001/PN_GrassLibrary/UE4ThirdPersonTemplate/ThirdPersonBP/Blueprints/ThirdPersonCharacter.ThirdPersonCharacter
LogBlueprint: Error: [Compiler] Could not find a function named "ResetOrientationAndPosition" in 'ThirdPersonCharacter'.
The following sets forth attribution notices for third party software that may be contained in portions of the Unicorn product. We thank the open source community for all of their contributions.
AFNetworking
The following software may be included in this product: AFNetworking. This software contains the following license and notice below:
Copyright (c) 2011-2016 Alamofire Software Foundation (http://alamofire.org/)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
UICKeyChainStore
The following software may be included in this product: UICKeyChainStore. This software contains the following license and notice below:
The MIT License
Copyright (c) 2011 kishikawa katsumi
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Toast
The following software may be included in this product: Toast. This software contains the following license and notice below:
Copyright (c) 2011-2017 Charles Scalesse.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Reachability
The following software may be included in this product: Reachability. This software contains the following license and notice below:
Copyright (c) 2011-2013, Tony Million.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
The following software may be included in this product: MMPulseView. This software contains the following license and notice below:
The MIT License (MIT)
Copyright (c) 2015 ralph li
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
firebase-ios-sdk
The following software may be included in this product: firebase-ios-sdk. This software contains the following license and notice below:
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Afile systemhandles the persistent storage of data files, apps, and the files associated with the operating system itself. Therefore, the file system is one of the fundamental resources used by all processes.
APFS is the default file system in macOS, iOS, watchOS, and tvOS. APFS replaces HFS+ as the default file system for iOS 10.3 and later, and macOS High Sierra and later. macOS additionally supports a variety of other formats, as described inSupported File Systems.
Regardless of the underlying format, all of the disks attached to the device—whether they are physically plugged in or are connected indirectly through the network—contribute space to create a single collection of files. Because the number of files can easily be many millions, the file system uses directories to create a hierarchical organization. Although the basic directory structures are similar for iOS and macOS, there are differences in the way each system organizes apps and user data.
Before you begin writing code that interacts with the file system, you should first understand a little about the organization of file system and the rules that apply to your code. Aside from the basic tenet that you cannot write files to directories for which you do not have appropriate security privileges, apps are also expected to be good citizens and put files in appropriate places. Precisely where you put files depends on the platform, but the overarching goal is to make sure that the user’s files remain easily discoverable and that the files your code uses internally are kept out of the user’s way.
About the iOS File System
The iOS file system is geared toward apps running on their own. To keep the system simple, users of iOS devices do not have direct access to the file system and apps are expected to follow this convention.
iOS Standard Directories: Where Files Reside
For security purposes, an iOS app’s interactions with the file system are limited to the directories inside the app’s sandbox directory. During installation of a new app, the installer creates a number of container directories for the app inside the sandbox directory. Each container directory has a specific role. The bundle container directory holds the app’s bundle, whereas the data container directory holds data for both the app and the user. The data container directory is further divided into a number of subdirectories that the app can use to sort and organize its data. The app may also request access to additional container directories—for example, the iCloud container—at runtime.
These container directories constitute the app’s primary view of the file system.Figure 1-1shows a representation of the sandbox directory for an app.
Figure 1-1 An iOS app operating within its own sandbox directory
An app is generally prohibited from accessing or creating files outside its container directories. One exception to this rule is when an app uses public system interfaces to access things such as the user’s contacts or music. In those cases, the system frameworks use helper apps to handle any file-related operations needed to read from or modify the appropriate data stores.
Table 1-1lists some of the more important subdirectories inside the sandbox directory and describes their intended usage. This table also describes any additional access restrictions for each subdirectory and points out whether the directory’s contents are backed up by iTunes and iCloud.
Table 1-1 Commonly used directories of an iOS appDirectoryDescription
The contents of this directory are not backed up by iTunes or iCloud. However, iTunes does perform an initial sync of any apps purchased from the App Store.
Documents/
Use this directory to store user-generated content. The contents of this directory can be made available to the user through file sharing; therefore, this directory should only contain files that you may wish to expose to the user. The contents of this directory are backed up by iTunes and iCloud.
Documents/Inbox
Use this directory to access files that your app was asked to open by outside entities. Specifically, the Mail program places email attachments associated with your app in this directory. Document interaction controllers may also place files in it. Your app can read and delete files in this directory but cannot create new files or write to existing files. If the user tries to edit a file in this directory, your app must silently move it out of the directory before making any changes. The contents of this directory are backed up by iTunes and iCloud.
Library/
This is the top-level directory for any files that are not user data files. You typically put files in one of several standard subdirectories. iOS apps commonly use theApplication SupportandCachessubdirectories; however, you can create custom subdirectories. Use theLibrarysubdirectories for any files you don’t want exposed to the user. Your app should not use these directories for user data files. The contents of theLibrarydirectory (with the exception of theCachessubdirectory) are backed up by iTunes and iCloud. For additional information about the Library directory and its commonly used subdirectories, seeThe Library Directory Stores App-Specific Files.
tmp/
Use this directory to write temporary files that do not need to persist between launches of your app. Your app should remove files from this directory when they are no longer needed; however, the system may purge this directory when your app is not running. The contents of this directory are not backed up by iTunes or iCloud.
An iOS app may create additional directories in theDocuments,Library, andtmpdirectories. You might do this to better organize the files in those locations.
To prevent the syncing and backup processes on iOS devices from taking a long time, be selective about where you place files. Apps that store large files can slow down the process of backing up to iTunes or iCloud. These apps can also consume a large amount of a user's available storage, which may encourage the user to delete the app or disable backup of that app's data to iCloud. With this in mind, you should store app data according to the following guidelines:
Put user data inDocuments/. User data generally includes any files you might want to expose to the user—anything you might want the user to create, import, delete or edit. For a drawing app, user data includes any graphic files the user might create. For a text editor, it includes the text files. Video and audio apps may even include files that the user has downloaded to watch or listen to later.
Put app-created support files in theLibrary/Application support/directory. In general, this directory includes files that the app uses to run but that should remain hidden from the user. This directory can also include data files, configuration files, templates and modified versions of resources loaded from the app bundle.
Remember that files inDocuments/andApplication Support/are backed up by default. You can exclude files from the backup by calling-[NSURL setResourceValue:forKey:error:]using theNSURLIsExcludedFromBackupKeykey. Any file that can be re-created or downloaded must be excluded from the backup. This is particularly important for large media files. If your application downloads video or audio files, make sure they are not included in the backup.
Put temporary data in thetmp/directory. Temporary data comprises any data that you do not need to persist for an extended period of time. Remember to delete those files when you are done with them so that they do not continue to consume space on the user’s device. The system will periodically purge these files when your app is not running; therefore, you cannot rely on these files persisting after your app terminates.
Put data cache files in theLibrary/Caches/directory. Cache data can be used for any data that needs to persist longer than temporary data, but not as long as a support file. Generally speaking, the application does not require cache data to operate properly, but it can use cache data to improve performance. Examples of cache data include (but are not limited to) database cache files and transient, downloadable content. Note that the system may delete theCaches/directory to free up disk space, so your app must be able to re-create or download these files as needed.
About the macOS File System
The macOS file system is designed for Mac computers, where both users and software have access to the file system. Users access the file system directly through the Finder, which presents a user-oriented view of the file system by hiding or renaming some files and directories. Apps access the file system using the system interfaces, which show the complete file system precisely as it appears on disk.
Domains Determine the Placement of Files
In macOS, the file system is divided into multiple domains, which separate files and resources based on their intended usage. This separation provides simplicity for the user, who only needs to worry about a specific subset of files. Arranging files by domain also lets the system apply blanket access privileges to files in that domain, preventing unauthorized users from changing files intentionally or inadvertently.
Theuser domaincontains resources specific to the users who log in to the system. Although it technically encompasses all users, this domain reflects only the home directory of the current user at runtime. User home directories can reside on the computer’s boot volume (in the/Usersdirectory) or on a network volume. Each user (regardless of privileges) has access to and control over the files in their own home directory.
Thelocal domaincontains resources such as apps that are local to the current computer and shared among all users of that computer. The local domain does not correspond to a single physical directory, but instead consists of several directories on the local boot (and root) volume. This domain is typically managed by the system, but users with administrative privileges may add, remove, or modify items in this domain.
Thenetwork domaincontains resources such as apps and documents that are shared among all users of a local area network. Items in this domain are typically located on network file servers and are under the control of a network administrator.
Thesystem domaincontains the system software installed by Apple. The resources in the system domain are required by the system to run. Users cannot add, remove, or alter items in this domain.
Figure 1-2shows how the local, system, and user domains map to the local file system of a macOS installation. (The network domain is not shown but is similar in many ways to the local domain.) This figure shows the visible directories that the user might see. Depending on the user’s system, other directories may be visible or some of the ones shown here may be hidden.
Whether provided by the system or created by your app, every file has its place in macOS.Table 1-2lists some of the top-level directories in a macOS installation and the types of content that each one contains.
Table 1-2 Commonly used directories in macOSDirectoryUsage
/Applications
This directory is where you install apps intended for use by all users of a computer. The App Store installs apps purchased by the user in this directory automatically. TheUtilitiessubdirectory contains a subset of apps that are intended for use in managing the local system. This directory is part of the local domain.
Library
There are multipleLibrarydirectories on the system, each one associated with a different domain or specific user. Apps should use theLibrarydirectory to store app-specific (or system-specific) resources. For detailed information about the contents of this directory and how you use it to support your apps, seeThe Library Directory Stores App-Specific Files.
/Network
This directory contains the list of computers in the local area network. There is no guarantee that files located on network file servers will have the/Networkdirectory at the beginning of their path. Path names vary depending on several factors, including how the network volume was mounted. For example, if the user uses the Connect to Server command to mount a volume, paths begin with the/Volumesdirectory. When writing code, assume that files on any volume other than the boot volume could be located on a network-based server.
/System
This directory contains the system resources required by macOS to run. These resources are provided by Apple and must not be modified. This directory comprises the contents of the system domain.
/Users
This directory contains one or more user home directories. The user home directory is where user-related files are stored. A typical user’s home directory includes the following subdirectories:
Applications—Contains user-specific apps.
Desktop—Contains the items on the user’s desktop.
Documents—Contains user documents and files.
Downloads—Contains files downloaded from the Internet.
Library—Contains user-specific app files (hidden in macOS 10.7 and later).
Movies—Contains the user’s video files.
Music—Contains the user’s music files.
Pictures—Contains the user’s photos.
Public—Contains content the user wants to share.
Sites—Contains web pages used by the user’s personal site. (Web Sharing must be enabled to display these pages.)
The preceding directories are for storing user documents and media only. Apps must not write files to the preceding directories unless explicitly directed to do so by the user. The sole exception to this rule is theLibrarydirectory, which apps may use to store data files needed to support the current user. Of the subdirectories, only thePublicdirectory is accessible by other users on the system. Access to the other directories is restricted by default.
Important: The files in the user’sDocumentsandDesktopdirectories should reflect only the documents that the user created and works with directly. Similarly, the media directories should contain only the user’s media files. Those directories must never be used to store data files that your app creates and manages automatically. If you need a place to store automatically generated files, use theLibrarydirectory, which is designated specifically for that purpose. For information on where to put files in the Library directory, seeThe Library Directory Stores App-Specific Files.
Although the directories inTable 1-2are the ones seen by macOS users, they are not the only directories present in the file system. macOS hides many directories to prevent users from accessing files that they don’t need to.
Sandboxed macOS App File Containers
macOS apps that are sandboxed have all theirApplication Support,Cache, temporary directories and other related documents stored within a directory located at a system-defined path that you can obtain by calling theNSHomeDirectoryfunction.
Hidden Files and Directories: Simplifying the User Experience
To simplify the experience for users, the Finder, and some specific user-facing interfaces (such as the Open and Save panels), hide many files and directories that the user should never have to use. Many of the hidden items are system- or app-specific resources that users cannot (or should not) access directly. Among the files and directories that are hidden are the following:
Dot directories and files.Any file or directory whose name starts with a period (.) character is hidden automatically. This convention is taken from UNIX, which used it to hide system scripts and other special types of files and directories. Two special directories in this category are the.and..directories, which are references to the current and parent directories respectively.
UNIX-specific directories.The directories in this category are inherited from traditional UNIX installations. They are an important part of the system’s BSD layer but are more useful to software developers than end users. Some of the more important directories that are hidden include:
/bin—Contains essential command-line binaries. Typically, you execute these binaries from command-line scripts.
/dev—Contains essential device files, such as mount points for attached hardware.
/etc—Contains host-specific configuration files.
/sbin—Contains essential system binaries.
/tmp—Contains temporary files created by apps and the system.
/usr—Contains non-essential command-line binaries, libraries, header files, and other data.
/var—Contains log files and other files whose content is variable. (Log files are typically viewed using the Console app.)
Explicitly hidden files and directories.The Finder may hide specific files or directories that should not be accessed directly by the user. The most notable example of this is the/Volumesdirectory, which contains a subdirectory for each mounted disk in the local file system from the command line. (The Finder provides a different user interface for accessing local disks.) In macOS 10.7 and later, the Finder also hides the~/Librarydirectory—that is, theLibrarydirectory located in the user’s home directory.
Packages and bundles.Packages and bundles are directories that the Finder presents to the user as if they were files. Bundles hide the internal workings of executables such as apps and just present a single entity that can be moved around the file system easily. Similarly, packages allow apps to implement complex document formats consisting of multiple individual files while still presenting what appears to be a single document to the user.
Although the Finder and other system interfaces hide files and directories from the user, Cocoa interfaces such asNSFileManagerdo not filter out files or directories that are normally invisible to users. Thus, code that uses these interfaces theoretically has a complete view of the file system and its contents. (Of course, a process really has access to only those files and directories for which it has appropriate permissions.)
Files and Directories Can Have Alternate Names
In some situations, the Finder presents users with file or directory names that do not match the actual names as they appear in the file system. These names are known asdisplay namesand are used only by the Finder and specific system components (such as the Open and Save panels) when presenting file and directory information to the user. Display names improve the user experience by presenting the user with content in a more friendly way. For example, macOS uses display names in the following situations:
Localized names.The system provides localized names for many system directories, such asApplications,Library,Music,Movies. An app may similarly provide localized names for itself and for any directories it creates.
Filename extension hiding.The system hides filename extensions for all files by default. The user may change option, but when filename extension hiding is in effect, the characters after the last period in a filename (and the period itself) are not displayed.
Display names do not affect the actual name of the file in the file system. Code that accesses a file or directory programmatically must specify the item’s actual name when opening or manipulating the item using the file system interfaces. The only time your app should ever use display names is when displaying the name of a file or directory to the user. You can get the display name for any file or directory using thedisplayNameAtPath:method ofNSFileManager.
Important: Your code should not allow users to modify display names directly. When you want the user to specify the name of a file, use a Save panel.
TheLibrarydirectory is where apps and other code modules store their custom data files. Regardless of whether you are writing code for iOS or macOS, understanding the structure of theLibrarydirectory is important. You use this directory to store data files, caches, resources, preferences, and even user data in some specific situations.
There are severalLibrarydirectories throughout the system but only a few that your code should ever need to access:
Libraryin the current home directory—This is the version of the directory you use the most because it is the one that contains all user-specific files. In iOS,Libraryis placed inside the apps data bundle. In macOS, it is the app’s sandbox directory or the current user’s home directory (if the app is not in a sandbox).
/Library(macOS only)—Apps that share resources between users store those resources in this version of theLibrarydirectory. Sandboxed apps are not permitted to use this directory.
/System/Library(macOS only)—This directory is reserved for use by Apple.
After selecting which version of the Library directory to use, you still need to know where to store your files. The Library directory itself contains several subdirectories that subdivide app-specific content into a few well-known categories.Table 1-3lists the most common subdirectories that you might use. Although Library directories in macOS contain many more subdirectories than the ones listed, most are used only by the system. If you want a more complete list of subdirectories, though, seemacOS Library Directory Details.
Table 1-3 Key subdirectories of the Library directoryDirectoryUsage
Application Support
Use this directory to store all app data files except those associated with the user’s documents. For example, you might use this directory to store app-created data files, configuration files, templates, or other fixed or modifiable resources that are managed by the app. An app might use this directory to store a modifiable copy of resources contained initially in the app’s bundle. A game might use this directory to store new levels purchased by the user and downloaded from a server. All content in this directory should be placed in a custom subdirectory whose name is that of your app’s bundle identifier or your company. In iOS, the contents of this directory are backed up by iTunes and iCloud.
Caches
Use this directory to write any app-specific support files that your app can re-create easily. Your app is generally responsible for managing the contents of this directory and for adding and deleting files as needed. In iOS 2.2 and later, the contents of this directory are not backed up by iTunes or iCloud. In addition, the system removes files in this directory during a full restoration of the device. In iOS 5.0 and later, the system may delete theCachesdirectory on rare occasions when the system is very low on disk space. This will never occur while an app is running. However, be aware that restoring from backup is not necessarily the only condition under which the Caches directory can be erased.
Frameworks
In macOS, frameworks that must be shared by multiple apps can be installed in either the local or user domain. The Frameworks directory in the system domain stores the frameworks you use to create your macOS apps. In iOS, apps cannot install custom frameworks.
Preferences
This directory contains app-specific preference files. You should not create files in this directory yourself. Instead, use theNSUserDefaultsclass or CFPreferences API to get and set preference values for your app. In iOS, the contents of this directory are backed up by iTunes and iCloud.
The iCloud File Storage Container
iCloud provides a structured system for storing files for apps that make use of iCloud:
Apps have a primary iCloud container directory for storing their native files. They can also access secondary iCloud container directories listed in their app entitlements.
Inside each container directory, files are segregated into "documents" and data. Every file or file package located in theDocumentssubdirectory (or one of its subdirectories) is presented to the user (via the iCloud UI in macOS and iOS) as a separate document that can be deleted individually. Anything not inDocumentsor one of its subdirectories is treated as data and shown as a single entry in the iCloud UI.
Documents that the user creates and sees in an app's user interface—for example the document browsers in Pages, Numbers, and Keynote should be stored in theDocumentsdirectory. Another example of files that might go in theDocumentsdirectory are saved games, again because they are something that an app could potentially provide some sort of method for selecting.
Anything that the app does not want the user to see or modify directly should be placed outside of theDocumentsdirectory. Apps can create any subdirectories inside the container directory, so they can arrange private files as desired.
Apps create files and directories in iCloud container directories in exactly the same way as they create local files and directories. And all the file’s attributes are saved, if they add extended attributes to a file, those attributes are copied to iCloud and to the user's other devices too.
iCloud containers also allow the storage of key-value pairs that can be easily accessed without having to create a document format.
How the System Identifies the Type of Content in a File
There are two primary techniques for identifying the type of content in a file:
Uniform Type Identifiers (UTIs)
Filename extensions
Auniform type identifieris a string that uniquely identifies a class of entities considered to have a “type.” UTIs provide consistent identifiers for data that all apps and services can recognize and rely upon. They are also more flexible than most other techniques because you can use them to represent any type of data, not just files and directories. Examples of UTIs include:
public.text—A public type that identifies text data.
public.jpeg—A public type that identifies JPEG image data.
com.apple.bundle—An Apple type that identifies a bundle directory.
com.apple.application-bundle—An Apple type that identifies a bundled app.
Whenever a UTI-based interface is available for specifying file types, you should prefer that interface over any others. Many macOS interfaces allow you to specify UTIs corresponding to the files or directories you want to work with. For example, in the Open panel, you can use UTIs as file filters and limit the types of files the user selects to ones your app can handle. Several AppKit classes, includingNSDocument,NSPasteboard, andNSImage, support UTIs. In iOS, UTIs are used to specify pasteboard types only.
One way the system determines the UTI for a given file is by looking at its filename extension. Afilename extensionis a string of characters appended to the end of a file and separated from the main filename with a period. Each unique string of characters identifies a file of a specific type. For example, the.stringsextension identifies a resource file with localizable string data while the.pngextension identifies a file with image data in the portable network graphics format.
Note: Because period characters are valid characters in macOS and iOS filenames, only the characters after the last period in a filename are considered part of the filename extension. Everything to the left of the last period is considered part of the filename itself.
If your app defines custom file formats, you should register those formats and any associated filename extensions in your app’sInfo.plistfile. TheCFBundleDocumentTypeskey specifies the file formats that your app recognizes and is able to open. Entries for any custom file formats should include both a filename extension and UTI corresponding to the file contents. The system uses that information to direct files with the appropriate type to your app.
Because all user data and system code are stored on disk somewhere, protecting the integrity of files and the file system is an important job. For that reason, there are several ways to secure content and prevent it from being stolen or damaged by other processes.
For general information about secure coding practices when working with files, seeSecure Coding Guide.
Sandboxes Limit the Spread of Damage
In iOS and in macOS 10.7 and later, sandboxes prevent apps from writing to parts of the file system that they should not write to. Each sandboxed app receives one or more containers that it can write into. An app cannot write to other apps’ containers or to most directories outside of the sandbox. These restrictions limit the potential damage that can be done in the event that an app’s security is breached.
Developers writing apps for macOS 10.7 and later are encouraged to put their apps in sandboxes to enhance security. Developers of iOS apps do not have to explicitly put their app in a sandbox because the system does it for them automatically at install time.
Permissions and Access Control Lists Govern All Access to Files
Access to files and directories is governed by a mixture of access control lists (ACLs) and BSD permissions. Access control lists are a set of fine-grained controls that define exactly what can and cannot be done to a file or directory and by whom. With access control lists, you can grant individual users different levels of access to a given file or directory. By contrast, BSD permissions only allow you to give access to three classes of users: the file’s owner, a single group of users that you specify, and all users. SeeSecurity Overviewfor more information.
Note: For a file on a network server, do not make any assumptions about the ACLs and BSD permissions associated with the file. Some network file systems provide only a summarized version of this information.
Because iOS apps always run in a sandbox, the system assigns specific ACLs and permissions to files created by each app. However, macOS apps can use Identity Services to manage access control lists for files to which they have access. For information about how to use Identity Services (and the Collaboration framework), seeIdentity Services Programming Guide.
Files Can Be Encrypted On Disk
Both macOS and iOS provide support for encrypting files on disk:
iOS.An iOS app can designate files that it wants to be encrypted on disk. When the user unlocks a device containing encrypted files, the system creates a decryption key that allows the app to access its encrypted files. When the user locks the device, though, the decryption key is destroyed to prevent unauthorized access to the files.
macOS.Users can encrypt the contents of a volume using the Disk Utility app. (They can also encrypt just the boot volume from the Security & Privacy system preference.) The contents of an encrypted disk are available to apps only while the computer is running. When the user puts the computer to sleep or shuts it down, the decryption keys are destroyed to prevent unauthorized access to the disk’s contents.
In iOS, apps that take advantage of disk-based encryption need to be discontinue the use of encrypted files when the user locks the device. Because locking the device destroys the decryption keys, access to encrypted files is limited to when the device is unlocked. If your iOS app can run in the background while the device is locked, it must do so without access to any of its encrypted files. Because encrypted disks in macOS are always accessible while the computer is running, macOS apps do not need to do anything special to handle disk-level encryption.
Synchronization Ensures Robustness in Your File-Related Code
The file system is a resource shared by third-party apps and system apps. Because multiple apps are able to access files and directories at the same time, the potential arises for one app to make changes that render a second app’s view of the file system obsolete. If the second app is not prepared to handle such changes, it could enter an unknown state or even crash. In cases where your app relies on the presence of specific files, you can use synchronization interfaces to be notified of changes to those files.
File system synchronization is primarily an issue in macOS, where the user can manipulate files directly with the Finder or with any number of other apps at the same time. Fortunately, macOS provides the following interfaces to help with synchronization issues:
File coordinators.In macOS 10.7 and later, file coordinators are a way to incorporate fine-grained synchronization support directly into the objects of your app; seeThe Role of File Coordinators and Presenters.
FSEvents.In macOS 10.5 and later, file system events allow you to monitor changes to a directory or its contents; seeFile System Events Programming Guide.
Files, Concurrency, and Thread Safety
Because file-related operations involve interacting with the hard disk and are therefore slow compared to most other operations, most of the file-related interfaces in iOS and macOS are designed with concurrency in mind. Several technologies incorporate asynchronous operation into their design and most others can execute safely from a dispatch queue or secondary thread.Table 1-4lists some of the key technologies discussed in this document and whether they are safe to use from specific threads or any thread. For specific information about the capabilities of any interface, see the reference documentation for that interface.
Table 1-4 Thread safety of key classes and technologiesClass/TechnologyNotes
For most tasks, it is safe to use the defaultNSFileManagerobject simultaneously from multiple background threads. The only exception to this rule is tasks that interact with the file manager’s delegate. When using a file manager object with a delegate, it is recommended that you create a unique instance of theNSFileManagerclass and use your delegate with that instance. You should then use your unique instance from one thread at a time.
Grand Central Dispatch
GCD itself is safe to use from any thread. However, you are still responsible for writing your blocks in a way that is thread safe.
Most of the Foundation objects you use to read and write file data can be used from any single thread but should not be used from multiple threads simultaneously.
Open and Save panels
Because they are part of your user interface, you should always present and manipulate the Open and Save panels from your app’s main thread.
POSIX routines
The POSIX routines for manipulating files are generally designed to operate safely from any thread. For details, see the corresponding man pages.
The immutable objects you use to specify paths are safe to use from any thread. Because they are immutable, you can also refer to them from multiple threads simultaneously. Of course, the mutable versions of these objects should be used from only one thread at a time.
Enumerator objects are safe to use from any single thread but should not be used from multiple threads simultaneously.
Even if you use an thread-safe interface for manipulating a file, problems can still arise when multiple threads or multiple processes attempt to act on the same file. Although there are safeguards to prevent multiple clients from modifying a file at the same time, those safeguards do not always guarantee exclusive access to the file at all times. (Nor should you attempt to prevent other processes from accessing shared files.) To make sure your code knows about changes made to shared files, use file coordinators to manage access to those files. For more information about file coordinators, seeThe Role of File Coordinators and Presenters
Java 8 Java 11애플릿 뷰어 도구 사용 가능 애플릿 뷰어 도구 사용 불가 AWTUtilities 클래스 사용하지 않는것이 좋음 AWTUtilities 클래스 사용 불가 String 문자열 관련 메소드가 적다 isBlank(), line(), repeat(n), stripLeading(), stripTrailing(), strip() 같은 새로운 String 문자열 방법이 도입됨 람다 파라미터에는 특수 변수가 사용되지 않음 람다식에 사용할 var 변수를 사용 할 수 있음 Java Deployment Technologies 사용 가능 Java Deployment Technologies 사용 불가 JMC 및 JavaFX는 Oracle JDK에서 사용 가능 JMC와 JavaFX는 자바 11의 Oracle JDK에서 제거 파일에 적합한 방법이 없음. writeString(), readString(), isSameFile()과 같은 다양한 메소드가 있어 파일에 대해 여러 작업을 수행 할 수 있음. 패턴을 인식 할 수 없음 패턴 인식은 asMatchPredicate(() 메스드이 도움으로 가능
