Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1d39ec0317 | ||
|
|
281b6468a0 | ||
|
|
9ba6da1f4d | ||
|
|
bde7a7fed6 | ||
|
|
6a5289b2a2 | ||
|
|
081a5df82c | ||
|
|
3e77ec8008 | ||
|
|
b0b222afa8 | ||
|
|
d85d6f627d | ||
|
|
9505f93da6 | ||
|
|
1671034330 | ||
|
|
3f0ca563e4 | ||
|
|
ffa2a5e8fd | ||
|
|
c3633895d0 | ||
|
|
c15af0a63a | ||
|
|
56e2d77039 | ||
|
|
2cf6fa14a1 | ||
|
|
c374725255 | ||
|
|
babfb6b8d6 | ||
|
|
2ffa8ec7d0 | ||
|
|
b516119224 | ||
|
|
c0e6bb97d8 | ||
|
|
cc30223ff1 | ||
|
|
53c8748942 | ||
|
|
b3a8966e71 | ||
|
|
74800a0767 | ||
|
|
cadd1f993d | ||
|
|
a6619a628e | ||
|
|
456572f87c | ||
|
|
f024b96934 | ||
|
|
25c71bcd98 | ||
|
|
319e7ecc61 | ||
|
|
d9ece5e96a | ||
|
|
4bfe4450b1 | ||
|
|
f9f12ffb61 | ||
|
|
63f81d1033 | ||
|
|
2ac1ebeaa0 | ||
|
|
25437602d7 | ||
|
|
8159c71950 | ||
|
|
aa66af7ba6 | ||
|
|
be3633622c | ||
|
|
31655a641c | ||
|
|
b235f6fc6b | ||
|
|
76b297b173 | ||
|
|
1e5cff1d8b | ||
|
|
4e2296d5f6 | ||
|
|
18310632eb | ||
|
|
80ed8d9869 | ||
|
|
2a2658d440 | ||
|
|
710e549c03 | ||
|
|
47fae977dd | ||
|
|
0111919975 | ||
|
|
80837cb040 | ||
|
|
46153a8991 | ||
|
|
a9fccfd4ce | ||
|
|
dfb57e9438 | ||
|
|
eda2731702 | ||
|
|
f47eac5935 | ||
|
|
3bb4dece5a | ||
|
|
0504e231a1 | ||
|
|
6097e14617 | ||
|
|
0b149ce5f1 | ||
|
|
79384e7bf8 | ||
|
|
01eb79cac2 | ||
|
|
128b32c62c | ||
|
|
c1233bd26b | ||
|
|
e23f67def6 | ||
|
|
95f4b29be5 | ||
|
|
5727c708cf | ||
|
|
e49f0f99a1 | ||
|
|
84d340382b | ||
|
|
5bfb067d0f | ||
|
|
d8cb62a92c | ||
|
|
aab8cc40f9 | ||
|
|
9c82689f65 | ||
|
|
ce2755467d | ||
|
|
02b19402ae | ||
|
|
80af66e852 | ||
|
|
15cfa45646 | ||
|
|
ac63849b49 | ||
|
|
02142e352b | ||
|
|
3d92413372 | ||
|
|
5022ed2acc | ||
|
|
31b9d22649 | ||
|
|
7a54894015 | ||
|
|
7100345a09 | ||
|
|
929db15214 | ||
|
|
d9455926c5 | ||
|
|
ba5cd741e1 | ||
|
|
8c94b6243e | ||
|
|
f6473e3383 | ||
|
|
3cd9d6a604 | ||
|
|
142281777e | ||
|
|
8e7b8af180 | ||
|
|
c046cd02d5 | ||
|
|
f5508fcdf1 | ||
|
|
adc2eab6da | ||
|
|
702698d8aa | ||
|
|
73dbe1de37 | ||
|
|
c5706fa28b | ||
|
|
c906a9571e | ||
|
|
038712f431 | ||
|
|
ed2d2c6f86 | ||
|
|
e7158e5a4b | ||
|
|
c66df259a6 | ||
|
|
0b8437fa12 | ||
|
|
a32b6ebf82 | ||
|
|
edbda1696e | ||
|
|
ece218785c | ||
|
|
cc1b3609a1 | ||
|
|
0841aad07a | ||
|
|
30b04ed0c2 | ||
|
|
90b28b3dbd | ||
|
|
0f7ca8f24e | ||
|
|
726d85ebd0 | ||
|
|
c524de9198 | ||
|
|
2fbf03d8ca | ||
|
|
68b8112af0 | ||
|
|
975e83a015 | ||
|
|
1ddb02dbb7 | ||
|
|
1159204ed8 | ||
|
|
a5212e7741 | ||
|
|
1932fd72e3 | ||
|
|
c061fe091b | ||
|
|
3621983a4d | ||
|
|
b6656690ca | ||
|
|
0c9e82ee6b | ||
|
|
b8ebb1faf1 | ||
|
|
690575193f | ||
|
|
9e9cf63c90 | ||
|
|
f5dc213e53 | ||
|
|
138e9c1486 | ||
|
|
7053c0dc93 | ||
|
|
ee8a653b13 | ||
|
|
71fad7e97f | ||
|
|
04740eb928 | ||
|
|
8c63d58c96 | ||
|
|
991672d423 | ||
|
|
55ce38cc87 | ||
|
|
96f3390407 | ||
|
|
aa2426d4e4 | ||
|
|
d0e3e13852 | ||
|
|
a2a1e30d68 | ||
|
|
a6f08b9e0c | ||
|
|
e70842a38c | ||
|
|
2af98d7d42 | ||
|
|
f28eee34e8 | ||
|
|
208610b645 | ||
|
|
e38f8076bc | ||
|
|
6180e1a48b | ||
|
|
e8fe1cd14d | ||
|
|
75d1fa585c | ||
|
|
072ff4b02e | ||
|
|
d8c4e2a72e | ||
|
|
66396de6a3 | ||
|
|
1ca9f575ef | ||
|
|
272e074a15 | ||
|
|
9a738c3783 | ||
|
|
6b4519e959 | ||
|
|
9b1d5213a6 | ||
|
|
f9ed9a4505 | ||
|
|
3ed7ce5630 | ||
|
|
63cd8343c4 | ||
|
|
2d5f8aed24 | ||
|
|
b8d23d0965 | ||
|
|
f4ef92e653 | ||
|
|
c7430f4ae9 | ||
|
|
623fda3087 | ||
|
|
80f27f2b29 | ||
|
|
defbd73b4f | ||
|
|
5285982515 | ||
|
|
f83daa5a22 | ||
|
|
0a07c8f131 | ||
|
|
35481a92f5 | ||
|
|
0995d864e8 | ||
|
|
1a42e43573 | ||
|
|
132aa569fe | ||
|
|
e93a787bd6 | ||
|
|
d6f902653f | ||
|
|
d172d43ddf | ||
|
|
67909724e7 | ||
|
|
1c88cbc5f6 | ||
|
|
3fb4831804 | ||
|
|
b65570fb16 | ||
|
|
871e6e6f64 | ||
|
|
0cd92a96c0 | ||
|
|
ff31ddd2d5 | ||
|
|
e9f5b43785 | ||
|
|
36b41081ab | ||
|
|
1092313892 | ||
|
|
ce605cb8f3 | ||
|
|
0733d885fb | ||
|
|
ef6fe3d1d9 | ||
|
|
82a4fea81a | ||
|
|
14a0252819 | ||
|
|
849aeb65f0 | ||
|
|
a99dc6e93d | ||
|
|
1a5fcc1348 | ||
|
|
c9d88f5628 | ||
|
|
0910711aca | ||
|
|
6a1a9ef6bc | ||
|
|
ef1c059079 | ||
|
|
a05ab37373 | ||
|
|
7ea88cfd22 | ||
|
|
8d14fe6a90 | ||
|
|
49a05b42f9 | ||
|
|
b6da1d7769 | ||
|
|
7e2ad58edd | ||
|
|
7ad0d98404 | ||
|
|
b7052bba95 | ||
|
|
4a5618bcc4 | ||
|
|
c1850fe604 | ||
|
|
fccdf32c9f | ||
|
|
c474411e1b | ||
|
|
9033eac5b1 | ||
|
|
0ba0426591 | ||
|
|
9a9b540701 | ||
|
|
b8ddbb9a26 | ||
|
|
bc3c2b96ed | ||
|
|
622dc87d84 | ||
|
|
18edbdf404 | ||
|
|
02a3eab693 | ||
|
|
dded868a80 | ||
|
|
6fe878bdb9 | ||
|
|
505ece9e36 | ||
|
|
72acfa1e0c | ||
|
|
02cd8b9a44 | ||
|
|
f32250f431 | ||
|
|
1523cad044 | ||
|
|
ed55353700 | ||
|
|
8d3bd45102 | ||
|
|
f69753f6a0 | ||
|
|
b7e2e87ac1 | ||
|
|
3b98508986 | ||
|
|
36ebfc42d9 | ||
|
|
ae5f55ff65 | ||
|
|
01131da5b7 | ||
|
|
66ae865de0 | ||
|
|
8c50f08fec | ||
|
|
e69de47daf | ||
|
|
acef10e848 | ||
|
|
edb9d50d9e | ||
|
|
b989d4f6be | ||
|
|
84dd5c0eca | ||
|
|
db8daf20b7 | ||
|
|
cb985b5a03 | ||
|
|
28c4e38272 | ||
|
|
b29377dc2b | ||
|
|
ca09592a72 | ||
|
|
b0e14fae43 | ||
|
|
dfa68f126b | ||
|
|
4570f68727 | ||
|
|
4705acba55 | ||
|
|
1dea20a358 | ||
|
|
191f661b35 | ||
|
|
f3ab38ba8f | ||
|
|
2d0a892e70 | ||
|
|
00eefe87d7 | ||
|
|
f68fd96555 | ||
|
|
fc50a3242f | ||
|
|
64e9ce2bfa | ||
|
|
e8d04b1921 | ||
|
|
9fedf14e55 | ||
|
|
7d535ef7d1 | ||
|
|
85d610bcdf | ||
|
|
3af8b7bd0c | ||
|
|
6215d85581 | ||
|
|
308d9f5abd | ||
|
|
bcfabba038 | ||
|
|
69139b1987 | ||
|
|
3f8f9d9d73 | ||
|
|
2283579109 | ||
|
|
1e0af94ba2 | ||
|
|
dd631328e0 | ||
|
|
cca2a57c69 | ||
|
|
bbfbcacc6a | ||
|
|
3f95c1a9d5 | ||
|
|
7bd05e9b16 | ||
|
|
10742d7c51 | ||
|
|
bbf7940e45 | ||
|
|
f5af71f4e6 | ||
|
|
1ffcd67c9d | ||
|
|
cf8592ba12 | ||
|
|
1e1d036590 | ||
|
|
64afb6d305 | ||
|
|
20a9e018f7 | ||
|
|
a574c33ac6 | ||
|
|
d21e458fe1 | ||
|
|
bb3ba53c6e | ||
|
|
ba2e4df76b | ||
|
|
33e7e4bee3 | ||
|
|
b83dce2cb3 | ||
|
|
6821676853 | ||
|
|
52024986ee | ||
|
|
2e3342d20d | ||
|
|
419aa1d78f | ||
|
|
de4ddd578f | ||
|
|
5dd68a7ed4 | ||
|
|
881168dc7a | ||
|
|
295e427abe | ||
|
|
67c5d15f51 | ||
|
|
39a7f37f35 | ||
|
|
15d276b0bc | ||
|
|
4387025c48 | ||
|
|
52c20f02c7 | ||
|
|
413dab8094 | ||
|
|
6b1d11a04d | ||
|
|
5441379f38 | ||
|
|
52d954c64e | ||
|
|
415495fc16 | ||
|
|
4223298634 | ||
|
|
e058c71019 | ||
|
|
12b2bbfa26 | ||
|
|
7d22bfffa5 | ||
|
|
4ade80c8a9 | ||
|
|
9674381fc2 | ||
|
|
f6d91280d7 | ||
|
|
e4ebbd8f69 | ||
|
|
7f5560de6d | ||
|
|
0925171e07 | ||
|
|
900d3ad01d | ||
|
|
6a1efedc1f | ||
|
|
0f602e0e62 | ||
|
|
3a425fc47d | ||
|
|
36722cbbd8 | ||
|
|
9572336e96 | ||
|
|
4895cde474 | ||
|
|
21ca1a73cf | ||
|
|
457c1c6ae6 | ||
|
|
c1ff127101 | ||
|
|
5e815a5832 | ||
|
|
4604e9cd54 | ||
|
|
ef580a7680 | ||
|
|
2102776be8 | ||
|
|
f3af7a6b77 | ||
|
|
5abeceac1f | ||
|
|
22f73a0817 | ||
|
|
29b5aef73a | ||
|
|
3e602bce52 | ||
|
|
fe39901885 | ||
|
|
ee9e8b365c | ||
|
|
bd6fa35d4a | ||
|
|
5e1fdf66b0 | ||
|
|
d86e709b90 | ||
|
|
f82cffe882 | ||
|
|
3d88eb92c1 | ||
|
|
0811ebb52d | ||
|
|
491d431ea5 | ||
|
|
ceeebebcad | ||
|
|
04d766aba7 | ||
|
|
3b431e180e | ||
|
|
a2eab1577d | ||
|
|
f8dd3d05dc | ||
|
|
93993e62d6 | ||
|
|
483c88b958 | ||
|
|
4a1e846958 | ||
|
|
927b9afe7c | ||
|
|
9e8827f015 | ||
|
|
ca45f461ae | ||
|
|
7e5af11c2d | ||
|
|
102436274f | ||
|
|
49c26a76b4 | ||
|
|
d469ef7bf2 | ||
|
|
a5374cb876 | ||
|
|
a53e911a0c | ||
|
|
c4a78a149b | ||
|
|
3814912adf | ||
|
|
75ef652cb3 | ||
|
|
1eae3fe5dc | ||
|
|
d0bc383a79 | ||
|
|
ea5d31b530 | ||
|
|
e56ad19e81 | ||
|
|
ed393eb75c | ||
|
|
2e2d309d38 | ||
|
|
6bfb33adb2 | ||
|
|
05138e1db1 | ||
|
|
b65402db41 | ||
|
|
fbef187400 | ||
|
|
25d1b8b9e5 | ||
|
|
ec91594083 | ||
|
|
e67f55bd74 | ||
|
|
276a7f9d2a | ||
|
|
4888d7a567 | ||
|
|
767f78315b | ||
|
|
4311b218fb | ||
|
|
89892042dd | ||
|
|
a22dfb3864 | ||
|
|
f40c42dcf0 | ||
|
|
1d31aa9da3 | ||
|
|
f999073fb4 | ||
|
|
5eb7c64ec3 | ||
|
|
7e79818555 | ||
|
|
a51576b250 | ||
|
|
0bee2689d1 | ||
|
|
c232743963 | ||
|
|
c2d5f092b3 | ||
|
|
8e8e186de9 | ||
|
|
55f47a2b1b | ||
|
|
5c27b9eb90 | ||
|
|
a54166a27c | ||
|
|
2dcd2b13be |
No files matched your search
@@ -0,0 +1,129 @@
|
||||
version: 1.0.{build}
|
||||
|
||||
notifications:
|
||||
- provider: Slack
|
||||
incoming_webhook:
|
||||
secure: SyfpZAVQA8PEPdjqqc6Yav3i5wNOCFxNcoHx3oJPYSLs13PdDLpSPKPiYJgxTYogspCIFcskc8nMUkXC0s7P8AWCzTKtusjKchd8D+pJR2I=
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- appveyor
|
||||
|
||||
clone_folder: c:\projects\lbry
|
||||
|
||||
init:
|
||||
- ps: >-
|
||||
$env:Path += ";C:\MinGW\bin\"
|
||||
|
||||
gcc --version
|
||||
|
||||
mingw32-make --version
|
||||
|
||||
mkdir C:\temp
|
||||
|
||||
Invoke-WebRequest "https://pypi.python.org/packages/55/90/e987e28ed29b571f315afea7d317b6bf4a551e37386b344190cffec60e72/miniupnpc-1.9.tar.gz" -OutFile "C:\temp\miniupnpc-1.9.tar.gz"
|
||||
|
||||
cd C:\temp
|
||||
|
||||
7z e miniupnpc-1.9.tar.gz
|
||||
|
||||
7z x miniupnpc-1.9.tar
|
||||
|
||||
cd C:\temp\miniupnpc-1.9
|
||||
|
||||
mingw32-make.exe -f Makefile.mingw
|
||||
|
||||
C:\Python27\python.exe C:\temp\miniupnpc-1.9\setupmingw32.py build --compiler=mingw32
|
||||
|
||||
C:\Python27\python.exe C:\temp\miniupnpc-1.9\setupmingw32.py install
|
||||
|
||||
Invoke-WebRequest "https://github.com/lbryio/lbry/raw/master/packaging/windows/libs/gmpy-1.17-cp27-none-win32.whl" -OutFile "C:\temp\gmpy-1.17-cp27-none-win32.whl"
|
||||
|
||||
C:\Python27\Scripts\pip.exe install "C:\temp\gmpy-1.17-cp27-none-win32.whl"
|
||||
|
||||
C:\Python27\Scripts\pip.exe install pypiwin32==219
|
||||
|
||||
C:\Python27\Scripts\pip.exe install six==1.9.0
|
||||
|
||||
C:\Python27\Scripts\pip.exe install requests==2.9.1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install zope.interface==4.1.3
|
||||
|
||||
C:\Python27\Scripts\pip.exe install cx-freeze==4.3.3
|
||||
|
||||
C:\Python27\Scripts\pip.exe install cython==0.24.1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install Twisted==16.0.0
|
||||
|
||||
C:\Python27\Scripts\pip.exe install Yapsy==1.11.223
|
||||
|
||||
C:\Python27\Scripts\pip.exe install appdirs==1.4.0
|
||||
|
||||
C:\Python27\Scripts\pip.exe install argparse==1.2.1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install colorama==0.3.7
|
||||
|
||||
C:\Python27\Scripts\pip.exe install dnspython==1.12.0
|
||||
|
||||
C:\Python27\Scripts\pip.exe install ecdsa==0.13
|
||||
|
||||
C:\Python27\Scripts\pip.exe install jsonrpc==1.2
|
||||
|
||||
C:\Python27\Scripts\pip.exe install jsonrpclib==0.1.7
|
||||
|
||||
C:\Python27\Scripts\pip.exe install loggly-python-handler==1.0.0
|
||||
|
||||
C:\Python27\Scripts\pip.exe install pbkdf2==1.3
|
||||
|
||||
C:\Python27\Scripts\pip.exe install protobuf==3.0.0
|
||||
|
||||
C:\Python27\Scripts\pip.exe install pycrypto==2.6.1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install python-bitcoinrpc==0.1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install qrcode==5.2.2
|
||||
|
||||
C:\Python27\Scripts\pip.exe install requests_futures==0.9.7
|
||||
|
||||
C:\Python27\Scripts\pip.exe install seccure==0.3.1.3
|
||||
|
||||
C:\Python27\Scripts\pip.exe install simplejson==3.8.2
|
||||
|
||||
C:\Python27\Scripts\pip.exe install slowaes==0.1a1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install txJSON-RPC==0.3.1
|
||||
|
||||
C:\Python27\Scripts\pip.exe install unqlite==0.5.3
|
||||
|
||||
C:\Python27\Scripts\pip.exe install wsgiref==0.1.2
|
||||
|
||||
C:\Python27\Scripts\pip.exe install base58==0.2.2
|
||||
|
||||
C:\Python27\Scripts\pip.exe install googlefinance==0.7
|
||||
|
||||
C:\Python27\Scripts\pip.exe install git+https://github.com/lbryio/lbryum.git
|
||||
|
||||
cd C:\projects\lbry
|
||||
|
||||
install:
|
||||
- cmd: C:\Python27\python.exe setup_win32.py install
|
||||
|
||||
build_script:
|
||||
- cmd: C:\Python27\python.exe setup_win32.py build bdist_msi
|
||||
|
||||
test_script:
|
||||
- ps: >-
|
||||
C:\Python27\Scripts\pip.exe install mock
|
||||
|
||||
C:\Python27\Scripts\pip.exe install pylint
|
||||
|
||||
C:\Python27\python.exe C:\Python27\Scripts\trial.py C:\projects\lbry\tests
|
||||
|
||||
artifacts:
|
||||
- path: dist/*.msi
|
||||
name: msi
|
||||
- path: build/exe.win32-2.7/
|
||||
name: lbry-portable
|
||||
- path: packaging/windows/lbry-win32-app/LBRY-URI.reg
|
||||
name: LBRY-URI
|
||||
@@ -1,8 +1,7 @@
|
||||
[bumpversion]
|
||||
current_version = 0.3.8
|
||||
current_version = 0.4.2
|
||||
commit = True
|
||||
tag = True
|
||||
message = Bump version: {current_version} -> {new_version}
|
||||
|
||||
[bumpversion:file:lbrynet/__init__.py]
|
||||
|
||||
|
||||
@@ -25,3 +25,8 @@ lbrynet.egg-info/PKG-INFO
|
||||
*.decTest
|
||||
|
||||
.coverage
|
||||
|
||||
# temporary files from the twisted.trial test runner
|
||||
_trial_temp/
|
||||
|
||||
.DS_Store
|
||||
@@ -45,6 +45,7 @@ deploy:
|
||||
- provider: releases
|
||||
file: "${TRAVIS_BUILD_DIR}/`python setup.py --name`_`python setup.py -V`_amd64.deb"
|
||||
skip_cleanup: true
|
||||
prerelease: true
|
||||
on:
|
||||
tags: true
|
||||
condition: "$TRAVIS_OS_NAME = linux"
|
||||
@@ -54,6 +55,7 @@ deploy:
|
||||
- provider: releases
|
||||
file: "${TRAVIS_BUILD_DIR}/packaging/osx/lbry-osx-app/`python setup.py --name`.`python setup.py -V`.dmg"
|
||||
skip_cleanup: true
|
||||
prerelease: true
|
||||
on:
|
||||
tags: true
|
||||
condition: "$TRAVIS_OS_NAME = osx"
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
#### Installing the LBRY app
|
||||
--------------------------
|
||||
|
||||
Installing LBRY is simple. You can get a dmg installer for OS X (Mavericks and up) or a .deb for linux [here](https://lbry.io/get).
|
||||
Installing LBRY is simple. You can get a dmg installer for OS X or a .deb for linux [here](https://github.com/lbryio/lbry/releases/latest).
|
||||
|
||||
##### OS X
|
||||
Just drag and drop LBRY.app into your applications folder (replacing any older versions). When it's running you'll have a LBRY icon in your status bar.
|
||||
Just drag and drop LBRY.app into your applications folder (replacing any older versions). When it's running you'll have a LBRY icon in your status bar and the browser will open to the UI.
|
||||
|
||||
##### Linux
|
||||
Double click the .deb file and follow the prompts. The app can be started by searching "LBRY", and it can be turned off by clicking the red 'x' in the browser interface.
|
||||
@@ -17,7 +17,7 @@ On both systems you can also open the UI while the app is running by going to lb
|
||||
--------------------------
|
||||
|
||||
##### OS X
|
||||
You can install LBRY command line by running `curl -sL https://rawgit.com/lbryio/lbry-setup/master/lbry_setup_osx.sh | sudo bash` in a terminal. This script will install lbrynet and its dependancies, as well as the app. You can start LBRY by either starting the app or by running `lbrynet-daemon` from a terminal.
|
||||
You can install LBRY command line by running `curl -sL https://raw.githubusercontent.com/lbryio/lbry/master/packaging/osx/install_lbry_source.sh | sudo bash` in a terminal. This script will install lbrynet and its dependencies. You can start LBRY by running `lbrynet-daemon` from a terminal.
|
||||
|
||||
##### Linux
|
||||
On Ubuntu or Mint you can install the prerequisites and lbrynet by running
|
||||
|
||||
@@ -1,2 +1 @@
|
||||
include lbrynet/lbrynet_console/plugins/blindrepeater.yapsy-plugin
|
||||
recursive-include lbrynet/lbrynet_gui *.gif *.ico *.xbm *.conf
|
||||
@@ -1,8 +1,2 @@
|
||||
import logging
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
logging.getLogger(__name__).addHandler(logging.NullHandler())
|
||||
log.setLevel(logging.ERROR)
|
||||
|
||||
__version__ = "0.3.8"
|
||||
__version__ = "0.4.2"
|
||||
version = tuple(__version__.split('.'))
|
||||
@@ -0,0 +1,2 @@
|
||||
from events import *
|
||||
from api import AnalyticsApi as Api
|
||||
@@ -0,0 +1,71 @@
|
||||
import functools
|
||||
import json
|
||||
import logging
|
||||
|
||||
from requests import auth
|
||||
from requests_futures import sessions
|
||||
|
||||
from lbrynet import conf
|
||||
from lbrynet.analytics import utils
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def log_response(fn):
|
||||
def _log(future):
|
||||
if future.cancelled():
|
||||
log.warning('Request was unexpectedly cancelled')
|
||||
else:
|
||||
response = future.result()
|
||||
log.debug('Response (%s): %s', response.status_code, response.content)
|
||||
|
||||
@functools.wraps(fn)
|
||||
def wrapper(*args, **kwargs):
|
||||
future = fn(*args, **kwargs)
|
||||
future.add_done_callback(_log)
|
||||
return future
|
||||
return wrapper
|
||||
|
||||
|
||||
class AnalyticsApi(object):
|
||||
def __init__(self, session, url, write_key):
|
||||
self.session = session
|
||||
self.url = url
|
||||
self.write_key = write_key
|
||||
|
||||
@property
|
||||
def auth(self):
|
||||
return auth.HTTPBasicAuth(self.write_key, '')
|
||||
|
||||
@log_response
|
||||
def batch(self, events):
|
||||
"""Send multiple events in one request.
|
||||
|
||||
Each event needs to have its type specified.
|
||||
"""
|
||||
data = json.dumps({
|
||||
'batch': events,
|
||||
'sentAt': utils.now(),
|
||||
})
|
||||
log.debug('sending %s events', len(events))
|
||||
log.debug('Data: %s', data)
|
||||
return self.session.post(self.url + '/batch', json=data, auth=self.auth)
|
||||
|
||||
@log_response
|
||||
def track(self, event):
|
||||
"""Send a single tracking event"""
|
||||
log.debug('Sending track event: %s', event)
|
||||
import base64
|
||||
return self.session.post(self.url + '/track', json=event, auth=self.auth)
|
||||
|
||||
@classmethod
|
||||
def load(cls, session=None):
|
||||
"""Initialize an instance using values from lbry.io."""
|
||||
if not session:
|
||||
session = sessions.FuturesSession()
|
||||
return cls(
|
||||
session,
|
||||
conf.ANALYTICS_ENDPOINT,
|
||||
utils.deobfuscate(conf.ANALYTICS_TOKEN)
|
||||
)
|
||||
@@ -0,0 +1,47 @@
|
||||
from lbrynet.analytics import utils
|
||||
|
||||
|
||||
class Events(object):
|
||||
def __init__(self, context, lbry_id, session_id):
|
||||
self.context = context
|
||||
self.lbry_id = lbry_id
|
||||
self.session_id = session_id
|
||||
|
||||
def heartbeat(self):
|
||||
return {
|
||||
'userId': 'lbry',
|
||||
'event': 'Heartbeat',
|
||||
'properties': {
|
||||
'lbry_id': self.lbry_id,
|
||||
'session_id': self.session_id
|
||||
},
|
||||
'context': self.context,
|
||||
'timestamp': utils.now()
|
||||
}
|
||||
|
||||
|
||||
def make_context(platform, wallet, is_dev=False):
|
||||
# TODO: distinguish between developer and release instances
|
||||
return {
|
||||
'is_dev': is_dev,
|
||||
'app': {
|
||||
'name': 'lbrynet',
|
||||
'version': platform['lbrynet_version'],
|
||||
'ui_version': platform['ui_version'],
|
||||
'python_version': platform['python_version'],
|
||||
'wallet': {
|
||||
'name': wallet,
|
||||
# TODO: add in version info for lbrycrdd
|
||||
'version': platform['lbryum_version'] if wallet == 'lbryum' else None
|
||||
},
|
||||
},
|
||||
# TODO: expand os info to give linux/osx specific info
|
||||
'os': {
|
||||
'name': platform['os_system'],
|
||||
'version': platform['os_release']
|
||||
},
|
||||
'library': {
|
||||
'name': 'lbrynet-analytics',
|
||||
'version': '1.0.0'
|
||||
},
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
import datetime
|
||||
|
||||
from lbrynet.core.utils import *
|
||||
|
||||
|
||||
def now():
|
||||
"""Return utc now in isoformat with timezone"""
|
||||
return datetime.datetime.utcnow().isoformat() + 'Z'
|
||||
@@ -1,8 +1,11 @@
|
||||
"""
|
||||
Some network wide and also application specific parameters
|
||||
"""
|
||||
import os
|
||||
|
||||
|
||||
IS_DEVELOPMENT_VERSION = False
|
||||
|
||||
MAX_HANDSHAKE_SIZE = 2**16
|
||||
MAX_REQUEST_SIZE = 2**16
|
||||
MAX_BLOB_REQUEST_SIZE = 2**16
|
||||
@@ -10,6 +13,7 @@ MAX_RESPONSE_INFO_SIZE = 2**16
|
||||
MAX_BLOB_INFOS_TO_REQUEST = 20
|
||||
BLOBFILES_DIR = ".blobfiles"
|
||||
BLOB_SIZE = 2**21
|
||||
|
||||
MIN_BLOB_DATA_PAYMENT_RATE = .005 # points/megabyte
|
||||
MIN_BLOB_INFO_PAYMENT_RATE = .02 # points/1000 infos
|
||||
MIN_VALUABLE_BLOB_INFO_PAYMENT_RATE = .05 # points/1000 infos
|
||||
@@ -24,6 +28,15 @@ KNOWN_DHT_NODES = [('104.236.42.182', 4000),
|
||||
POINTTRADER_SERVER = 'http://ec2-54-187-192-68.us-west-2.compute.amazonaws.com:2424'
|
||||
#POINTTRADER_SERVER = 'http://127.0.0.1:2424'
|
||||
|
||||
if IS_DEVELOPMENT_VERSION:
|
||||
SEARCH_SERVERS = ["http://107.170.207.64:50005"]
|
||||
else:
|
||||
SEARCH_SERVERS = ["http://lighthouse1.lbry.io:50005",
|
||||
"http://lighthouse2.lbry.io:50005",
|
||||
"http://lighthouse3.lbry.io:50005"]
|
||||
|
||||
REFLECTOR_SERVERS = [("reflector.lbry.io", 5566)]
|
||||
|
||||
LOG_FILE_NAME = "lbrynet.log"
|
||||
LOG_POST_URL = "https://lbry.io/log-upload"
|
||||
|
||||
@@ -32,7 +45,10 @@ CRYPTSD_FILE_EXTENSION = ".cryptsd"
|
||||
API_INTERFACE = "localhost"
|
||||
API_ADDRESS = "lbryapi"
|
||||
API_PORT = 5279
|
||||
ICON_PATH = "app.icns"
|
||||
if os.name == "nt":
|
||||
ICON_PATH = "icons"
|
||||
else:
|
||||
ICON_PATH = "app.icns"
|
||||
APP_NAME = "LBRY"
|
||||
API_CONNECTION_STRING = "http://%s:%i/%s" % (API_INTERFACE, API_PORT, API_ADDRESS)
|
||||
UI_ADDRESS = "http://%s:%i" % (API_INTERFACE, API_PORT)
|
||||
@@ -42,11 +58,20 @@ DEFAULT_WALLET = "lbryum"
|
||||
WALLET_TYPES = ["lbryum", "lbrycrd"]
|
||||
DEFAULT_TIMEOUT = 30
|
||||
DEFAULT_MAX_SEARCH_RESULTS = 25
|
||||
DEFAULT_MAX_KEY_FEE = 100.0
|
||||
DEFAULT_MAX_KEY_FEE = {'USD': {'amount': 25.0, 'address': ''}}
|
||||
DEFAULT_SEARCH_TIMEOUT = 3.0
|
||||
DEFAULT_SD_DOWNLOAD_TIMEOUT = 3
|
||||
DEFAULT_CACHE_TIME = 3600
|
||||
DEFAULT_UI_BRANCH = "master"
|
||||
|
||||
SOURCE_TYPES = ['lbry_sd_hash', 'url', 'btih']
|
||||
BASE_METADATA_FIELDS = ['title', 'description', 'author', 'language', 'license', 'content-type']
|
||||
OPTIONAL_METADATA_FIELDS = ['thumbnail', 'preview', 'fee', 'contact', 'pubkey']
|
||||
CURRENCIES = {
|
||||
'BTC': {'type': 'crypto'},
|
||||
'LBC': {'type': 'crypto'},
|
||||
'USD': {'type': 'fiat'},
|
||||
}
|
||||
|
||||
LOGGLY_TOKEN = 'LJEzATH4AzRgAwxjAP00LwZ2YGx3MwVgZTMuBQZ3MQuxLmOv'
|
||||
|
||||
ANALYTICS_ENDPOINT = 'https://api.segment.io/v1'
|
||||
ANALYTICS_TOKEN = 'Ax5LZzR1o3q3Z3WjATASDwR5rKyHH0qOIRIbLmMXn2H='
|
||||
@@ -67,6 +67,9 @@ class BlobManager(DHTHashSupplier):
|
||||
def blob_paid_for(self, blob_hash, amount):
|
||||
pass
|
||||
|
||||
def get_all_verified_blobs(self):
|
||||
pass
|
||||
|
||||
|
||||
class DiskBlobManager(BlobManager):
|
||||
"""This class stores blobs on the hard disk"""
|
||||
@@ -78,7 +81,7 @@ class DiskBlobManager(BlobManager):
|
||||
self.blob_type = BlobFile
|
||||
self.blob_creator_type = BlobFileCreator
|
||||
self.blobs = {}
|
||||
self.blob_hashes_to_delete = {} # {blob_hash: being_deleted (True/False)}
|
||||
self.blob_hashes_to_delete = {} # {blob_hash: being_deleted (True/False)}
|
||||
self._next_manage_call = None
|
||||
|
||||
def setup(self):
|
||||
@@ -177,6 +180,11 @@ class DiskBlobManager(BlobManager):
|
||||
def check_consistency(self):
|
||||
return self._check_consistency()
|
||||
|
||||
def get_all_verified_blobs(self):
|
||||
d = self._get_all_verified_blob_hashes()
|
||||
d.addCallback(self.completed_blobs)
|
||||
return d
|
||||
|
||||
def _manage(self):
|
||||
from twisted.internet import reactor
|
||||
|
||||
@@ -462,6 +470,10 @@ class TempBlobManager(BlobManager):
|
||||
blobs = [b.blob_hash for b in self.blobs.itervalues() if b.blob_hash in blobs_to_check and b.is_validated()]
|
||||
return defer.succeed(blobs)
|
||||
|
||||
def get_all_verified_blobs(self):
|
||||
d = self.completed_blobs(self.blobs)
|
||||
return d
|
||||
|
||||
def hashes_to_announce(self):
|
||||
now = time.time()
|
||||
blobs = [blob_hash for blob_hash, announce_time in self.blob_next_announces.iteritems() if announce_time < now]
|
||||
|
||||
@@ -22,6 +22,10 @@ class ConnectionClosedBeforeResponseError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class KeyFeeAboveMaxAllowed(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnknownNameError(Exception):
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
@@ -30,6 +34,14 @@ class UnknownNameError(Exception):
|
||||
return repr(self.name)
|
||||
|
||||
|
||||
class InvalidNameError(Exception):
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
|
||||
def __str__(self):
|
||||
return repr(self.name)
|
||||
|
||||
|
||||
class UnknownStreamTypeError(Exception):
|
||||
def __init__(self, stream_type):
|
||||
self.stream_type = stream_type
|
||||
|
||||
@@ -1,16 +1,11 @@
|
||||
import sys
|
||||
from lbrynet.interfaces import IRequestCreator, IQueryHandlerFactory, IQueryHandler, ILBRYWallet
|
||||
from lbrynet.core.client.ClientRequest import ClientRequest
|
||||
from lbrynet.core.Error import UnknownNameError, InvalidStreamInfoError, RequestCanceledError
|
||||
from lbrynet.core.Error import InsufficientFundsError
|
||||
from lbrynet.core.sqlite_helpers import rerun_if_locked
|
||||
from lbrynet.conf import BASE_METADATA_FIELDS, SOURCE_TYPES, OPTIONAL_METADATA_FIELDS
|
||||
|
||||
from lbryum import SimpleConfig, Network
|
||||
from lbryum.lbrycrd import COIN, TYPE_ADDRESS
|
||||
from lbryum.wallet import WalletStorage, Wallet
|
||||
from lbryum.commands import known_commands, Commands
|
||||
from lbryum.transaction import Transaction
|
||||
import datetime
|
||||
import logging
|
||||
import json
|
||||
import subprocess
|
||||
import socket
|
||||
import time
|
||||
import os
|
||||
|
||||
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
|
||||
from twisted.internet import threads, reactor, defer, task
|
||||
@@ -19,13 +14,18 @@ from twisted.enterprise import adbapi
|
||||
from collections import defaultdict, deque
|
||||
from zope.interface import implements
|
||||
from decimal import Decimal
|
||||
import datetime
|
||||
import logging
|
||||
import json
|
||||
import subprocess
|
||||
import socket
|
||||
import time
|
||||
import os
|
||||
|
||||
from lbryum import SimpleConfig, Network
|
||||
from lbryum.lbrycrd import COIN
|
||||
from lbryum.wallet import WalletStorage, Wallet
|
||||
from lbryum.commands import known_commands, Commands
|
||||
from lbryum.transaction import Transaction
|
||||
|
||||
from lbrynet.interfaces import IRequestCreator, IQueryHandlerFactory, IQueryHandler, ILBRYWallet
|
||||
from lbrynet.core.client.ClientRequest import ClientRequest
|
||||
from lbrynet.core.Error import UnknownNameError, InvalidStreamInfoError, RequestCanceledError
|
||||
from lbrynet.core.Error import InsufficientFundsError
|
||||
from lbrynet.metadata.LBRYMetadata import Metadata
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
alert = logging.getLogger("lbryalert." + __name__)
|
||||
@@ -56,7 +56,6 @@ class LBRYWallet(object):
|
||||
_FIRST_RUN_NO = 2
|
||||
|
||||
def __init__(self, db_dir):
|
||||
|
||||
self.db_dir = db_dir
|
||||
self.db = None
|
||||
self.next_manage_call = None
|
||||
@@ -87,6 +86,7 @@ class LBRYWallet(object):
|
||||
return True
|
||||
|
||||
d = self._open_db()
|
||||
d.addCallback(lambda _: self._clean_bad_records())
|
||||
d.addCallback(lambda _: self._start())
|
||||
d.addCallback(lambda _: start_manage())
|
||||
return d
|
||||
@@ -98,6 +98,7 @@ class LBRYWallet(object):
|
||||
def stop(self):
|
||||
|
||||
self.stopped = True
|
||||
|
||||
# If self.next_manage_call is None, then manage is currently running or else
|
||||
# start has not been called, so set stopped and do nothing else.
|
||||
if self.next_manage_call is not None:
|
||||
@@ -288,7 +289,7 @@ class LBRYWallet(object):
|
||||
d = self._do_send_many(payments_to_send)
|
||||
d.addCallback(lambda txid: log.debug("Sent transaction %s", txid))
|
||||
return d
|
||||
log.info("There were no payments to send")
|
||||
log.debug("There were no payments to send")
|
||||
return defer.succeed(True)
|
||||
|
||||
def get_stream_info_for_name(self, name):
|
||||
@@ -316,58 +317,135 @@ class LBRYWallet(object):
|
||||
return d
|
||||
|
||||
def _get_stream_info_from_value(self, result, name):
|
||||
r_dict = {}
|
||||
if 'value' in result:
|
||||
value = result['value']
|
||||
def _check_result_fields(r):
|
||||
for k in ['value', 'txid', 'n', 'height', 'amount']:
|
||||
assert k in r, "getvalueforname response missing field %s" % k
|
||||
|
||||
try:
|
||||
value_dict = json.loads(value)
|
||||
except (ValueError, TypeError):
|
||||
return Failure(InvalidStreamInfoError(name))
|
||||
r_dict['sources'] = value_dict['sources']
|
||||
for field in BASE_METADATA_FIELDS:
|
||||
r_dict[field] = value_dict[field]
|
||||
for field in value_dict:
|
||||
if field in OPTIONAL_METADATA_FIELDS:
|
||||
r_dict[field] = value_dict[field]
|
||||
def _log_success(claim_id):
|
||||
log.info("lbry://%s complies with %s, claimid: %s", name, metadata.version, claim_id)
|
||||
return defer.succeed(None)
|
||||
|
||||
if 'txid' in result:
|
||||
d = self._save_name_metadata(name, r_dict['sources']['lbry_sd_hash'], str(result['txid']))
|
||||
d.addCallback(lambda _: r_dict)
|
||||
return d
|
||||
elif 'error' in result:
|
||||
if 'error' in result:
|
||||
log.warning("Got an error looking up a name: %s", result['error'])
|
||||
return Failure(UnknownNameError(name))
|
||||
|
||||
_check_result_fields(result)
|
||||
|
||||
try:
|
||||
metadata = Metadata(json.loads(result['value']))
|
||||
except (ValueError, TypeError):
|
||||
return Failure(InvalidStreamInfoError(name))
|
||||
|
||||
txid = result['txid']
|
||||
sd_hash = metadata['sources']['lbry_sd_hash']
|
||||
d = self._save_name_metadata(name, txid, sd_hash)
|
||||
d.addCallback(lambda _: self.get_claimid(name, txid))
|
||||
d.addCallback(lambda cid: _log_success(cid))
|
||||
d.addCallback(lambda _: metadata)
|
||||
return d
|
||||
|
||||
def get_claim(self, name, claim_id):
|
||||
d = self.get_claims_for_name(name)
|
||||
d.addCallback(lambda claims: next(claim for claim in claims['claims'] if claim['claimId'] == claim_id))
|
||||
return d
|
||||
|
||||
def get_claimid(self, name, txid):
|
||||
def _get_id_for_return(claim_id):
|
||||
if claim_id:
|
||||
return defer.succeed(claim_id)
|
||||
else:
|
||||
d = self.get_claims_from_tx(txid)
|
||||
d.addCallback(lambda claims: next(c['claimId'] for c in claims if c['name'] == name))
|
||||
d.addCallback(lambda cid: self._update_claimid(cid, name, txid))
|
||||
return d
|
||||
|
||||
d = self._get_claimid_for_tx(name, txid)
|
||||
d.addCallback(_get_id_for_return)
|
||||
return d
|
||||
|
||||
def get_claim_info(self, name, txid=None):
|
||||
if not txid:
|
||||
d = self._get_value_for_name(name)
|
||||
d.addCallback(lambda r: self._get_claim_info(name, r['txid']))
|
||||
else:
|
||||
log.warning("Got an error looking up a name: %s", json.dumps(result))
|
||||
return Failure(UnknownNameError(name))
|
||||
d = self._get_claim_info(name, txid)
|
||||
d.addErrback(lambda _: False)
|
||||
return d
|
||||
|
||||
def claim_name(self, name, bid, sources, metadata, fee=None):
|
||||
value = {'sources': {}}
|
||||
for k in SOURCE_TYPES:
|
||||
if k in sources:
|
||||
value['sources'][k] = sources[k]
|
||||
if value['sources'] == {}:
|
||||
return defer.fail("No source given")
|
||||
for k in BASE_METADATA_FIELDS:
|
||||
if k not in metadata:
|
||||
return defer.fail("Missing required field '%s'" % k)
|
||||
value[k] = metadata[k]
|
||||
for k in metadata:
|
||||
if k not in BASE_METADATA_FIELDS:
|
||||
value[k] = metadata[k]
|
||||
if fee is not None:
|
||||
if "LBC" in fee:
|
||||
value['fee'] = {'LBC': {'amount': fee['LBC']['amount'], 'address': fee['LBC']['address']}}
|
||||
def _get_claim_info(self, name, txid):
|
||||
def _build_response(claim):
|
||||
result = {}
|
||||
try:
|
||||
metadata = Metadata(json.loads(claim['value']))
|
||||
meta_ver = metadata.version
|
||||
sd_hash = metadata['sources']['lbry_sd_hash']
|
||||
d = self._save_name_metadata(name, txid, sd_hash)
|
||||
except AssertionError:
|
||||
metadata = claim['value']
|
||||
meta_ver = "Non-compliant"
|
||||
d = defer.succeed(None)
|
||||
|
||||
d = self._send_name_claim(name, json.dumps(value), bid)
|
||||
claim_id = claim['claimId']
|
||||
result['claim_id'] = claim_id
|
||||
result['amount'] = claim['nEffectiveAmount']
|
||||
result['height'] = claim['nHeight']
|
||||
result['name'] = name
|
||||
result['txid'] = txid
|
||||
result['value'] = metadata
|
||||
result['supports'] = [{'txid': support['txid'], 'n': support['n']} for support in claim['supports']]
|
||||
result['meta_version'] = meta_ver
|
||||
|
||||
def _save_metadata(txid):
|
||||
d = self._save_name_metadata(name, value['sources']['lbry_sd_hash'], txid)
|
||||
log.info("get claim info lbry://%s metadata: %s, claimid: %s", name, meta_ver, claim_id)
|
||||
|
||||
d.addCallback(lambda _: self.get_name_claims())
|
||||
d.addCallback(lambda r: [c['txid'] for c in r])
|
||||
d.addCallback(lambda my_claims: _add_is_mine(result, my_claims))
|
||||
return d
|
||||
|
||||
def _add_is_mine(response, my_txs):
|
||||
response['is_mine'] = response['txid'] in my_txs
|
||||
return response
|
||||
|
||||
d = self.get_claimid(name, txid)
|
||||
d.addCallback(lambda claim_id: self.get_claim(name, claim_id))
|
||||
d.addCallback(_build_response)
|
||||
return d
|
||||
|
||||
def get_claims_for_name(self, name):
|
||||
d = self._get_claims_for_name(name)
|
||||
return d
|
||||
|
||||
def update_metadata(self, new_metadata, old_metadata):
|
||||
meta_for_return = old_metadata if isinstance(old_metadata, dict) else {}
|
||||
for k in new_metadata:
|
||||
meta_for_return[k] = new_metadata[k]
|
||||
return defer.succeed(Metadata(meta_for_return))
|
||||
|
||||
def claim_name(self, name, bid, m):
|
||||
def _save_metadata(txid, metadata):
|
||||
log.info("Saving metadata for claim %s" % txid)
|
||||
d = self._save_name_metadata(name, txid, metadata['sources']['lbry_sd_hash'])
|
||||
d.addCallback(lambda _: txid)
|
||||
return d
|
||||
|
||||
d.addCallback(_save_metadata)
|
||||
def _claim_or_update(claim, metadata, _bid):
|
||||
if not claim:
|
||||
log.info("No claim yet, making a new one")
|
||||
return self._send_name_claim(name, metadata, _bid)
|
||||
if not claim['is_mine']:
|
||||
log.info("Making a contesting claim")
|
||||
return self._send_name_claim(name, metadata, _bid)
|
||||
else:
|
||||
log.info("Updating over own claim")
|
||||
d = self.update_metadata(metadata, claim['value'])
|
||||
d.addCallback(lambda new_metadata: self._send_name_claim_update(name, claim['claim_id'], claim['txid'], new_metadata, _bid))
|
||||
return d
|
||||
|
||||
meta = Metadata(m)
|
||||
|
||||
d = self.get_claim_info(name)
|
||||
d.addCallback(lambda claim: _claim_or_update(claim, meta, bid))
|
||||
d.addCallback(lambda txid: _save_metadata(txid, meta))
|
||||
return d
|
||||
|
||||
def abandon_name(self, txid):
|
||||
@@ -403,15 +481,39 @@ class LBRYWallet(object):
|
||||
dl.addCallback(abandon)
|
||||
return dl
|
||||
|
||||
def support_claim(self, name, claim_id, amount):
|
||||
return self._support_claim(name, claim_id, amount)
|
||||
|
||||
def get_tx(self, txid):
|
||||
d = self._get_raw_tx(txid)
|
||||
d.addCallback(self._get_decoded_tx)
|
||||
return d
|
||||
|
||||
def update_name(self, name, value, amount):
|
||||
d = self._get_value_for_name(name)
|
||||
d.addCallback(lambda r: (self._update_name(r['txid'], json.dumps(value), amount), r['txid']))
|
||||
d.addCallback(lambda (new_txid, old_txid): self._update_name_metadata(name, value['sources']['lbry_sd_hash'], old_txid, new_txid))
|
||||
def get_history(self):
|
||||
d = self._get_history()
|
||||
return d
|
||||
|
||||
def get_tx_json(self, txid):
|
||||
def _decode(raw_tx):
|
||||
tx = Transaction(raw_tx).deserialize()
|
||||
decoded_tx = {}
|
||||
for txkey in tx.keys():
|
||||
if isinstance(tx[txkey], list):
|
||||
decoded_tx[txkey] = []
|
||||
for i in tx[txkey]:
|
||||
tmp = {}
|
||||
for k in i.keys():
|
||||
if isinstance(i[k], Decimal):
|
||||
tmp[k] = float(i[k] / 1e8)
|
||||
else:
|
||||
tmp[k] = i[k]
|
||||
decoded_tx[txkey].append(tmp)
|
||||
else:
|
||||
decoded_tx[txkey] = tx[txkey]
|
||||
return decoded_tx
|
||||
|
||||
d = self._get_raw_tx(txid)
|
||||
d.addCallback(_decode)
|
||||
return d
|
||||
|
||||
def get_name_and_validity_for_sd_hash(self, sd_hash):
|
||||
@@ -516,27 +618,45 @@ class LBRYWallet(object):
|
||||
def _open_db(self):
|
||||
self.db = adbapi.ConnectionPool('sqlite3', os.path.join(self.db_dir, "blockchainname.db"),
|
||||
check_same_thread=False)
|
||||
return self.db.runQuery("create table if not exists name_metadata (" +
|
||||
|
||||
def create_tables(transaction):
|
||||
transaction.execute("create table if not exists name_metadata (" +
|
||||
" name text, " +
|
||||
" txid text, " +
|
||||
" sd_hash text)")
|
||||
transaction.execute("create table if not exists claim_ids (" +
|
||||
" claimId text, " +
|
||||
" name text, " +
|
||||
" txid text)")
|
||||
|
||||
def _save_name_metadata(self, name, sd_hash, txid):
|
||||
d = self.db.runQuery("select * from name_metadata where txid=?", (txid,))
|
||||
d.addCallback(lambda r: self.db.runQuery("insert into name_metadata values (?, ?, ?)", (name, txid, sd_hash))
|
||||
if not len(r) else None)
|
||||
return self.db.runInteraction(create_tables)
|
||||
|
||||
def _clean_bad_records(self):
|
||||
d = self.db.runQuery("delete from name_metadata where length(txid) > 64 or txid is null")
|
||||
return d
|
||||
|
||||
def _update_name_metadata(self, name, sd_hash, old_txid, new_txid):
|
||||
d = self.db.runQuery("delete * from name_metadata where txid=? and sd_hash=?", (old_txid, sd_hash))
|
||||
d.addCallback(lambda _: self.db.runQuery("insert into name_metadata values (?, ?, ?)", (name, new_txid, sd_hash)))
|
||||
d.addCallback(lambda _: new_txid)
|
||||
def _save_name_metadata(self, name, txid, sd_hash):
|
||||
assert len(txid) == 64, "That's not a txid: %s" % str(txid)
|
||||
d = self.db.runQuery("delete from name_metadata where name=? and txid=? and sd_hash=?", (name, txid, sd_hash))
|
||||
d.addCallback(lambda _: self.db.runQuery("insert into name_metadata values (?, ?, ?)", (name, txid, sd_hash)))
|
||||
return d
|
||||
|
||||
def _get_claim_metadata_for_sd_hash(self, sd_hash):
|
||||
d = self.db.runQuery("select name, txid from name_metadata where sd_hash=?", (sd_hash,))
|
||||
d.addCallback(lambda r: r[0] if len(r) else None)
|
||||
d.addCallback(lambda r: r[0] if r else None)
|
||||
return d
|
||||
|
||||
def _update_claimid(self, claim_id, name, txid):
|
||||
assert len(txid) == 64, "That's not a txid: %s" % str(txid)
|
||||
d = self.db.runQuery("delete from claim_ids where claimId=? and name=? and txid=?", (claim_id, name, txid))
|
||||
d.addCallback(lambda r: self.db.runQuery("insert into claim_ids values (?, ?, ?)", (claim_id, name, txid)))
|
||||
d.addCallback(lambda _: claim_id)
|
||||
return d
|
||||
|
||||
def _get_claimid_for_tx(self, name, txid):
|
||||
assert len(txid) == 64, "That's not a txid: %s" % str(txid)
|
||||
d = self.db.runQuery("select claimId from claim_ids where name=? and txid=?", (name, txid))
|
||||
d.addCallback(lambda r: r[0][0] if r else None)
|
||||
return d
|
||||
|
||||
######### Must be overridden #########
|
||||
@@ -559,6 +679,9 @@ class LBRYWallet(object):
|
||||
def get_name_claims(self):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _get_claims_for_name(self, name):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _check_first_run(self):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
@@ -574,7 +697,10 @@ class LBRYWallet(object):
|
||||
def _send_abandon(self, txid, address, amount):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _update_name(self, txid, value, amount):
|
||||
def _send_name_claim_update(self, name, claim_id, txid, value, amount):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _support_claim(self, name, claim_id, amount):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _do_send_many(self, payments_to_send):
|
||||
@@ -589,6 +715,9 @@ class LBRYWallet(object):
|
||||
def _get_balance_for_address(self, address):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _get_history(self):
|
||||
return defer.fail(NotImplementedError())
|
||||
|
||||
def _start(self):
|
||||
pass
|
||||
|
||||
@@ -631,7 +760,7 @@ class LBRYcrdWallet(LBRYWallet):
|
||||
settings = {"username": "rpcuser",
|
||||
"password": "rpcpassword",
|
||||
"rpc_port": 9245}
|
||||
if os.path.exists(self.wallet_conf):
|
||||
if self.wallet_conf and os.path.exists(self.wallet_conf):
|
||||
conf = open(self.wallet_conf)
|
||||
for l in conf:
|
||||
if l.startswith("rpcuser="):
|
||||
@@ -709,15 +838,24 @@ class LBRYcrdWallet(LBRYWallet):
|
||||
def _send_abandon(self, txid, address, amount):
|
||||
return threads.deferToThread(self._send_abandon_rpc, txid, address, amount)
|
||||
|
||||
def _update_name(self, txid, value, amount):
|
||||
def _send_name_claim_update(self, name, claim_id, txid, value, amount):
|
||||
return threads.deferToThread(self._update_name_rpc, txid, value, amount)
|
||||
|
||||
def _support_claim(self, name, claim_id, amount):
|
||||
return threads.deferToThread(self._support_claim_rpc, name, claim_id, amount)
|
||||
|
||||
def _get_claims_for_name(self, name):
|
||||
return threads.deferToThread(self._get_claims_for_name_rpc, name)
|
||||
|
||||
def get_claims_from_tx(self, txid):
|
||||
return threads.deferToThread(self._get_claims_from_tx_rpc, txid)
|
||||
|
||||
def _get_value_for_name(self, name):
|
||||
return threads.deferToThread(self._get_value_for_name_rpc, name)
|
||||
|
||||
def _get_history(self):
|
||||
return threads.deferToThread(self._list_transactions_rpc)
|
||||
|
||||
def _get_rpc_conn(self):
|
||||
return AuthServiceProxy(self.rpc_conn_string)
|
||||
|
||||
@@ -846,6 +984,11 @@ class LBRYcrdWallet(LBRYWallet):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.getclaimsfortx(txid)
|
||||
|
||||
@_catch_connection_error
|
||||
def _get_claims_for_name_rpc(self, name):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.getclaimsforname(name)
|
||||
|
||||
@_catch_connection_error
|
||||
def _get_nametrie_rpc(self):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
@@ -866,21 +1009,27 @@ class LBRYcrdWallet(LBRYWallet):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.getvalueforname(name)
|
||||
|
||||
@_catch_connection_error
|
||||
def _update_name_rpc(self, txid, value, amount):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.updateclaim(txid, value, amount)
|
||||
return rpc_conn.updateclaim(txid, json.dumps(value), amount)
|
||||
|
||||
@_catch_connection_error
|
||||
def _send_name_claim_rpc(self, name, value, amount):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
try:
|
||||
return str(rpc_conn.claimname(name, value, amount))
|
||||
return str(rpc_conn.claimname(name, json.dumps(value), amount))
|
||||
except JSONRPCException as e:
|
||||
if 'message' in e.error and e.error['message'] == "Insufficient funds":
|
||||
raise InsufficientFundsError()
|
||||
elif 'message' in e.error:
|
||||
raise ValueError(e.error['message'])
|
||||
|
||||
@_catch_connection_error
|
||||
def _support_claim_rpc(self, name, claim_id, amount):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.supportclaim(name, claim_id, amount)
|
||||
|
||||
@_catch_connection_error
|
||||
def _get_num_addresses_rpc(self):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
@@ -891,6 +1040,11 @@ class LBRYcrdWallet(LBRYWallet):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.getbestblockhash()
|
||||
|
||||
@_catch_connection_error
|
||||
def _list_transactions_rpc(self):
|
||||
rpc_conn = self._get_rpc_conn()
|
||||
return rpc_conn.listtransactions()
|
||||
|
||||
@_catch_connection_error
|
||||
def _stop_rpc(self):
|
||||
# check if our lbrycrdd is actually running, or if we connected to one that was already
|
||||
@@ -924,7 +1078,7 @@ class LBRYumWallet(LBRYWallet):
|
||||
network_start_d = defer.Deferred()
|
||||
|
||||
def setup_network():
|
||||
self.config = SimpleConfig()
|
||||
self.config = SimpleConfig({'auto_connect': True})
|
||||
self.network = Network(self.config)
|
||||
alert.info("Loading the wallet...")
|
||||
return defer.succeed(self.network.start())
|
||||
@@ -996,7 +1150,7 @@ class LBRYumWallet(LBRYWallet):
|
||||
blockchain_caught_d = defer.Deferred()
|
||||
|
||||
def check_caught_up():
|
||||
local_height = self.network.get_local_height()
|
||||
local_height = self.network.get_catchup_progress()
|
||||
remote_height = self.network.get_server_height()
|
||||
|
||||
if remote_height != 0 and remote_height - local_height <= 5:
|
||||
@@ -1088,12 +1242,31 @@ class LBRYumWallet(LBRYWallet):
|
||||
def send_claim(address):
|
||||
cmd = known_commands['claimname']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
return threads.deferToThread(func, address, amount, name, val)
|
||||
return threads.deferToThread(func, address, amount, name, json.dumps(val))
|
||||
d = self.get_new_address()
|
||||
d.addCallback(send_claim)
|
||||
d.addCallback(self._broadcast_transaction)
|
||||
return d
|
||||
|
||||
def _get_claims_for_name(self, name):
|
||||
cmd = known_commands['getclaimsforname']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
return threads.deferToThread(func, name)
|
||||
|
||||
def _send_name_claim_update(self, name, claim_id, txid, value, amount):
|
||||
def send_claim_update(address):
|
||||
decoded_claim_id = claim_id.decode('hex')[::-1]
|
||||
metadata = json.dumps(value)
|
||||
log.info("updateclaim %s %s %f %s %s '%s'", txid, address, amount, name, decoded_claim_id.encode('hex'), metadata)
|
||||
cmd = known_commands['updateclaim']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
return threads.deferToThread(func, txid, address, amount, name, decoded_claim_id, metadata)
|
||||
|
||||
d = self.get_new_address()
|
||||
d.addCallback(send_claim_update)
|
||||
d.addCallback(self._broadcast_transaction)
|
||||
return d
|
||||
|
||||
def _get_decoded_tx(self, raw_tx):
|
||||
tx = Transaction(raw_tx)
|
||||
decoded_tx = {}
|
||||
@@ -1105,28 +1278,41 @@ class LBRYumWallet(LBRYWallet):
|
||||
return decoded_tx
|
||||
|
||||
def _send_abandon(self, txid, address, amount):
|
||||
log.info("Abandon " + str(txid) + " " + str(address) + " " + str(amount))
|
||||
log.info("Abandon %s %s %f" % (txid, address, amount))
|
||||
cmd = known_commands['abandonclaim']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
d = threads.deferToThread(func, txid, address, amount)
|
||||
d.addCallback(self._broadcast_transaction)
|
||||
return d
|
||||
|
||||
def _support_claim(self, name, claim_id, amount):
|
||||
def _send_support(d, a, n, c):
|
||||
cmd = known_commands['supportclaim']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
d = threads.deferToThread(func, d, a, n, c)
|
||||
return d
|
||||
d = self.get_new_address()
|
||||
d.addCallback(lambda address: _send_support(address, amount, name, claim_id))
|
||||
d.addCallback(self._broadcast_transaction)
|
||||
return d
|
||||
|
||||
def _broadcast_transaction(self, raw_tx):
|
||||
log.info("Broadcast: " + str(raw_tx))
|
||||
def _log_tx(r):
|
||||
log.info("Broadcast tx: %s", r)
|
||||
return r
|
||||
cmd = known_commands['broadcast']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
d = threads.deferToThread(func, raw_tx)
|
||||
d.addCallback(_log_tx)
|
||||
d.addCallback(lambda r: r if len(r) == 64 else defer.fail(Exception("Transaction rejected")))
|
||||
d.addCallback(self._save_wallet)
|
||||
return d
|
||||
|
||||
def _do_send_many(self, payments_to_send):
|
||||
log.warning("Doing send many. payments to send: %s", str(payments_to_send))
|
||||
outputs = [(TYPE_ADDRESS, address, int(amount*COIN)) for address, amount in payments_to_send.iteritems()]
|
||||
d = threads.deferToThread(self.wallet.mktx, outputs, None, self.config)
|
||||
d.addCallback(lambda tx: threads.deferToThread(self.wallet.sendtx, tx))
|
||||
d.addCallback(self._save_wallet)
|
||||
return d
|
||||
cmd = known_commands['paytomanyandsend']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
return threads.deferToThread(func, payments_to_send.iteritems())
|
||||
|
||||
def _get_value_for_name(self, name):
|
||||
cmd = known_commands['getvalueforname']
|
||||
@@ -1146,34 +1332,11 @@ class LBRYumWallet(LBRYWallet):
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
return threads.deferToThread(func)
|
||||
|
||||
def get_history(self):
|
||||
def _get_history(self):
|
||||
cmd = known_commands['history']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
return threads.deferToThread(func)
|
||||
|
||||
def get_tx_json(self, txid):
|
||||
def _decode(raw_tx):
|
||||
tx = Transaction(raw_tx).deserialize()
|
||||
decoded_tx = {}
|
||||
for txkey in tx.keys():
|
||||
if isinstance(tx[txkey], list):
|
||||
decoded_tx[txkey] = []
|
||||
for i in tx[txkey]:
|
||||
tmp = {}
|
||||
for k in i.keys():
|
||||
if isinstance(i[k], Decimal):
|
||||
tmp[k] = float(i[k] / 1e8)
|
||||
else:
|
||||
tmp[k] = i[k]
|
||||
decoded_tx[txkey].append(tmp)
|
||||
else:
|
||||
decoded_tx[txkey] = tx[txkey]
|
||||
return decoded_tx
|
||||
|
||||
d = self._get_raw_tx(txid)
|
||||
d.addCallback(_decode)
|
||||
return d
|
||||
|
||||
def get_pub_keys(self, wallet):
|
||||
cmd = known_commands['getpubkeys']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
|
||||
@@ -173,14 +173,23 @@ class LBRYSession(object):
|
||||
self.upnp_redirects.append((self.peer_port, 'TCP'))
|
||||
log.info("Set UPnP redirect for TCP port %d", self.peer_port)
|
||||
else:
|
||||
# see comment below
|
||||
log.warning("UPnP redirect already set for TCP port %d", self.peer_port)
|
||||
self.upnp_redirects.append((self.peer_port, 'TCP'))
|
||||
if self.dht_node_port is not None:
|
||||
if u.getspecificportmapping(self.dht_node_port, 'UDP') is None:
|
||||
u.addportmapping(self.dht_node_port, 'UDP', u.lanaddr, self.dht_node_port, 'LBRY DHT port', '')
|
||||
self.upnp_redirects.append((self.dht_node_port, 'UDP'))
|
||||
log.info("Set UPnP redirect for UPD port %d", self.dht_node_port)
|
||||
else:
|
||||
# TODO: check that the existing redirect was put up by an old lbrynet session before grabbing it
|
||||
# if such a disconnected redirect exists, then upnp won't work unless the redirect is appended
|
||||
# or is torn down and set back up. a bad shutdown of lbrynet could leave such a redirect up
|
||||
# and cause problems on the next start.
|
||||
# this could be problematic if a previous lbrynet session didn't make the redirect, and it was
|
||||
# made by another application
|
||||
log.warning("UPnP redirect already set for UDP port %d", self.dht_node_port)
|
||||
self.upnp_redirects.append((self.dht_node_port, 'UDP'))
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
@@ -198,7 +198,7 @@ class StreamDescriptorIdentifier(object):
|
||||
return self._stream_downloader_factories[stream_type]
|
||||
|
||||
def _get_validator(self, stream_type):
|
||||
if not stream_type in self._stream_downloader_factories:
|
||||
if not stream_type in self._sd_info_validators:
|
||||
raise UnknownStreamTypeError(stream_type)
|
||||
return self._sd_info_validators[stream_type]
|
||||
|
||||
@@ -238,4 +238,4 @@ def download_sd_blob(session, blob_hash, payment_rate_manager):
|
||||
"""
|
||||
downloader = StandaloneBlobDownloader(blob_hash, session.blob_manager, session.peer_finder,
|
||||
session.rate_limiter, payment_rate_manager, session.wallet)
|
||||
return downloader.download()
|
||||
return downloader.download()
|
||||
@@ -73,7 +73,7 @@ class ClientProtocol(Protocol):
|
||||
return defer.fail(failure.Failure(ValueError("There is already a request for that response active")))
|
||||
self._next_request.update(request.request_dict)
|
||||
d = defer.Deferred()
|
||||
log.debug("Adding a request. Request: %s", str(request))
|
||||
log.debug("Adding a request. Request: %s", str(request.request_dict))
|
||||
self._response_deferreds[request.response_identifier] = d
|
||||
return d
|
||||
|
||||
|
||||
@@ -172,6 +172,7 @@ class ConnectionManager(object):
|
||||
def pick_best_peer(peers):
|
||||
# TODO: Eventually rank them based on past performance/reputation. For now
|
||||
# TODO: just pick the first to which we don't have an open connection
|
||||
|
||||
log.debug("Got a list of peers to choose from: %s", str(peers))
|
||||
if peers is None:
|
||||
return None
|
||||
|
||||
@@ -66,7 +66,7 @@ class DownloadManager(object):
|
||||
|
||||
def add_blobs_to_download(self, blob_infos):
|
||||
|
||||
log.debug("Adding %s to blobs", str(blob_infos))
|
||||
log.debug("Adding %s blobs to blobs", len(blob_infos))
|
||||
|
||||
def add_blob_to_list(blob, blob_num):
|
||||
self.blobs[blob_num] = blob
|
||||
|
||||
@@ -0,0 +1,132 @@
|
||||
import json
|
||||
import logging
|
||||
import logging.handlers
|
||||
import sys
|
||||
import traceback
|
||||
|
||||
from requests_futures.sessions import FuturesSession
|
||||
|
||||
import lbrynet
|
||||
from lbrynet import conf
|
||||
from lbrynet.core import utils
|
||||
|
||||
session = FuturesSession()
|
||||
|
||||
|
||||
def bg_cb(sess, resp):
|
||||
""" Don't do anything with the response """
|
||||
pass
|
||||
|
||||
|
||||
class HTTPSHandler(logging.Handler):
|
||||
def __init__(self, url, fqdn=False, localname=None, facility=None):
|
||||
logging.Handler.__init__(self)
|
||||
self.url = url
|
||||
self.fqdn = fqdn
|
||||
self.localname = localname
|
||||
self.facility = facility
|
||||
|
||||
def get_full_message(self, record):
|
||||
if record.exc_info:
|
||||
return '\n'.join(traceback.format_exception(*record.exc_info))
|
||||
else:
|
||||
return record.getMessage()
|
||||
|
||||
def emit(self, record):
|
||||
try:
|
||||
payload = self.format(record)
|
||||
session.post(self.url, data=payload, background_callback=bg_cb)
|
||||
except (KeyboardInterrupt, SystemExit):
|
||||
raise
|
||||
except:
|
||||
self.handleError(record)
|
||||
|
||||
|
||||
DEFAULT_FORMAT = "%(asctime)s %(levelname)-8s %(name)s:%(lineno)d: %(message)s"
|
||||
DEFAULT_FORMATTER = logging.Formatter(DEFAULT_FORMAT)
|
||||
LOGGLY_URL = "https://logs-01.loggly.com/inputs/{token}/tag/{tag}"
|
||||
|
||||
|
||||
def remove_handlers(log, handler_name):
|
||||
for handler in log.handlers:
|
||||
if handler.name == handler_name:
|
||||
log.removeHandler(handler)
|
||||
|
||||
|
||||
def _log_decorator(fn):
|
||||
def helper(*args, **kwargs):
|
||||
log = kwargs.pop('log', logging.getLogger())
|
||||
level = kwargs.pop('level', logging.INFO)
|
||||
if not isinstance(level, int):
|
||||
# despite the name, getLevelName returns
|
||||
# the numeric level when passed a text level
|
||||
level = logging.getLevelName(level)
|
||||
handler = fn(*args, **kwargs)
|
||||
if handler.name:
|
||||
remove_handlers(log, handler.name)
|
||||
handler.setLevel(level)
|
||||
log.addHandler(handler)
|
||||
if log.level > level:
|
||||
log.setLevel(level)
|
||||
return helper
|
||||
|
||||
|
||||
def disable_third_party_loggers():
|
||||
logging.getLogger('requests').setLevel(logging.WARNING)
|
||||
|
||||
|
||||
def disable_noisy_loggers():
|
||||
logging.getLogger('BitcoinRPC').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.analytics.api').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.core.client.ConnectionManager').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.core.client.BlobRequester').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.core.client.ClientProtocol').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.core.server.ServerRequestHandler').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.core.server.ServerProtocol').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.core.server.BlobAvailabilityHandler').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.dht').setLevel(logging.INFO)
|
||||
logging.getLogger('lbrynet.lbrynet_daemon.LBRYExchangeRateManager').setLevel(logging.INFO)
|
||||
|
||||
|
||||
@_log_decorator
|
||||
def configure_console(**kwargs):
|
||||
"""Convenience function to configure a logger that outputs to stdout"""
|
||||
handler = logging.StreamHandler(sys.stdout)
|
||||
handler.setFormatter(DEFAULT_FORMATTER)
|
||||
handler.name = 'console'
|
||||
return handler
|
||||
|
||||
|
||||
@_log_decorator
|
||||
def configure_file_handler(file_name, **kwargs):
|
||||
handler = logging.handlers.RotatingFileHandler(file_name, maxBytes=2097152, backupCount=5)
|
||||
handler.setFormatter(DEFAULT_FORMATTER)
|
||||
handler.name = 'file'
|
||||
return handler
|
||||
|
||||
|
||||
def get_loggly_url(token=None, version=None):
|
||||
token = token or utils.deobfuscate(conf.LOGGLY_TOKEN)
|
||||
version = version or lbrynet.__version__
|
||||
return LOGGLY_URL.format(token=token, tag='lbrynet-' + version)
|
||||
|
||||
|
||||
@_log_decorator
|
||||
def configure_loggly_handler(url=None, **kwargs):
|
||||
url = url or get_loggly_url()
|
||||
json_format = {
|
||||
"loggerName": "%(name)s",
|
||||
"asciTime": "%(asctime)s",
|
||||
"fileName": "%(filename)s",
|
||||
"functionName": "%(funcName)s",
|
||||
"levelNo": "%(levelno)s",
|
||||
"lineNo": "%(lineno)d",
|
||||
"levelName": "%(levelname)s",
|
||||
"message": "%(message)s",
|
||||
}
|
||||
json_format.update(kwargs)
|
||||
formatter = logging.Formatter(json.dumps(json_format))
|
||||
handler = HTTPSHandler(url)
|
||||
handler.setFormatter(formatter)
|
||||
handler.name = 'loggly'
|
||||
return handler
|
||||
@@ -44,6 +44,7 @@ class BlobAvailabilityHandler(object):
|
||||
d = self._get_available_blobs(queries[self.query_identifiers[0]])
|
||||
|
||||
def set_field(available_blobs):
|
||||
log.debug("available blobs: %s", str(available_blobs))
|
||||
return {'available_blobs': available_blobs}
|
||||
|
||||
d.addCallback(set_field)
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import binascii
|
||||
from twisted.internet import defer, task, reactor
|
||||
from twisted.internet import defer, reactor
|
||||
import collections
|
||||
|
||||
|
||||
@@ -78,4 +78,4 @@ class DHTHashSupplier(object):
|
||||
self.hash_reannounce_time = 60 * 60 # 1 hour
|
||||
|
||||
def hashes_to_announce(self):
|
||||
pass
|
||||
pass
|
||||
@@ -99,8 +99,8 @@ class ServerRequestHandler(object):
|
||||
d.addCallback(lambda _: self.blob_sender.send_blob_if_requested(self))
|
||||
d.addCallbacks(lambda _: self.finished_response(), self.request_failure_handler)
|
||||
else:
|
||||
log.info("Request buff not a valid json message")
|
||||
log.info("Request buff: %s", str(self.request_buff))
|
||||
log.debug("Request buff not a valid json message")
|
||||
log.debug("Request buff: %s", str(self.request_buff))
|
||||
else:
|
||||
log.warning("The client sent data when we were uploading a file. This should not happen")
|
||||
|
||||
@@ -125,7 +125,7 @@ class ServerRequestHandler(object):
|
||||
|
||||
def send_response(self, msg):
|
||||
m = json.dumps(msg)
|
||||
log.info("Sending a response of length %s", str(len(m)))
|
||||
log.debug("Sending a response of length %s", str(len(m)))
|
||||
log.debug("Response: %s", str(m))
|
||||
self.response_buff = self.response_buff + m
|
||||
self._produce_more()
|
||||
@@ -171,4 +171,4 @@ class ServerRequestHandler(object):
|
||||
msg = json.loads(request_buff)
|
||||
return msg
|
||||
except ValueError:
|
||||
return None
|
||||
return None
|
||||
@@ -1,6 +1,10 @@
|
||||
from lbrynet.core.cryptoutils import get_lbry_hash_obj
|
||||
import base64
|
||||
import distutils.version
|
||||
import random
|
||||
|
||||
from lbrynet.core.cryptoutils import get_lbry_hash_obj
|
||||
|
||||
|
||||
|
||||
blobhash_length = get_lbry_hash_obj().digest_size * 2 # digest_size is in bytes, and blob hashes are hex encoded
|
||||
|
||||
@@ -25,4 +29,20 @@ def is_valid_blobhash(blobhash):
|
||||
for l in blobhash:
|
||||
if l not in "0123456789abcdef":
|
||||
return False
|
||||
return True
|
||||
return True
|
||||
|
||||
|
||||
def version_is_greater_than(a, b):
|
||||
"""Returns True if version a is more recent than version b"""
|
||||
try:
|
||||
return distutils.version.StrictVersion(a) > distutils.version.StrictVersion(b)
|
||||
except ValueError:
|
||||
return distutils.version.LooseVersion(a) > distutils.version.LooseVersion(b)
|
||||
|
||||
|
||||
def deobfuscate(obfustacated):
|
||||
return base64.b64decode(obfustacated.decode('rot13'))
|
||||
|
||||
|
||||
def obfuscate(plain):
|
||||
return base64.b64encode(plain).encode('rot13')
|
||||
@@ -1,9 +1,12 @@
|
||||
import logging
|
||||
import os
|
||||
|
||||
|
||||
def migrate_db(db_dir, start, end):
|
||||
current = start
|
||||
old_dirs = []
|
||||
if os.name == "nt":
|
||||
return old_dirs
|
||||
while current < end:
|
||||
if current == 0:
|
||||
from lbrynet.db_migrator.migrate0to1 import do_migration
|
||||
|
||||
@@ -8,10 +8,7 @@
|
||||
# may be created by processing this file with epydoc: http://epydoc.sf.net
|
||||
|
||||
import UserDict
|
||||
#import sqlite3
|
||||
import cPickle as pickle
|
||||
import time
|
||||
import os
|
||||
import constants
|
||||
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
# The docstrings in this module contain epytext markup; API documentation
|
||||
# may be created by processing this file with epydoc: http://epydoc.sf.net
|
||||
|
||||
import hashlib, random, struct, time, math, binascii
|
||||
import hashlib, random, struct, time, binascii
|
||||
import argparse
|
||||
from twisted.internet import defer, error
|
||||
import constants
|
||||
@@ -240,9 +240,9 @@ class Node(object):
|
||||
known_nodes = {}
|
||||
|
||||
def log_error(err, n):
|
||||
log.error("error storing blob_hash %s at %s", binascii.hexlify(blob_hash), str(n))
|
||||
log.error(binascii.hexlify(err.getErrorMessage()))
|
||||
log.error(err.getTraceback())
|
||||
log.debug("error storing blob_hash %s at %s", binascii.hexlify(blob_hash), str(n))
|
||||
log.debug(err.getErrorMessage())
|
||||
log.debug(err.getTraceback())
|
||||
|
||||
def log_success(res):
|
||||
log.debug("Response to store request: %s", str(res))
|
||||
@@ -1017,4 +1017,4 @@ def main():
|
||||
twisted.internet.reactor.run()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
main()
|
||||
@@ -7,6 +7,7 @@
|
||||
# The docstrings in this module contain epytext markup; API documentation
|
||||
# may be created by processing this file with epydoc: http://epydoc.sf.net
|
||||
|
||||
import binascii
|
||||
import time
|
||||
|
||||
from twisted.internet import protocol, defer
|
||||
@@ -23,6 +24,13 @@ reactor = twisted.internet.reactor
|
||||
|
||||
class TimeoutError(Exception):
|
||||
""" Raised when a RPC times out """
|
||||
def __init__(self, remote_contact_id):
|
||||
# remote_contact_id is a binary blob so we need to convert it
|
||||
# into something more readable
|
||||
msg = 'Timeout connecting to {}'.format(binascii.hexlify(remote_contact_id))
|
||||
Exception.__init__(self, msg)
|
||||
self.remote_contact_id = remote_contact_id
|
||||
|
||||
|
||||
class KademliaProtocol(protocol.DatagramProtocol):
|
||||
""" Implements all low-level network-related functions of a Kademlia node """
|
||||
|
||||
@@ -20,7 +20,7 @@
|
||||
|
||||
|
||||
|
||||
import os, sys, time, signal, hashlib, random
|
||||
import sys, hashlib, random
|
||||
import twisted.internet.reactor
|
||||
from lbrynet.dht.node import Node
|
||||
#from entangled.kademlia.datastore import SQLiteDataStore
|
||||
@@ -106,7 +106,7 @@ def stop():
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
import sys, os
|
||||
import sys
|
||||
if len(sys.argv) < 2:
|
||||
print 'Usage:\n%s UDP_PORT [KNOWN_NODE_IP KNOWN_NODE_PORT]' % sys.argv[0]
|
||||
print 'or:\n%s UDP_PORT [FILE_WITH_KNOWN_NODES]' % sys.argv[0]
|
||||
|
||||
@@ -48,7 +48,7 @@ class DBLBRYFileMetadataManager(object):
|
||||
return self._add_blobs_to_stream(stream_hash, blobs, ignore_duplicate_error=True)
|
||||
|
||||
def get_blobs_for_stream(self, stream_hash, start_blob=None, end_blob=None, count=None, reverse=False):
|
||||
log.info("Getting blobs for a stream. Count is %s", str(count))
|
||||
log.debug("Getting blobs for a stream. Count is %s", str(count))
|
||||
|
||||
def get_positions_of_start_and_end():
|
||||
if start_blob is not None:
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
from lbrynet.lbryfile.StreamDescriptor import get_sd_info
|
||||
from lbrynet.lbryfile.StreamDescriptor import publish_sd_blob
|
||||
@@ -11,7 +11,6 @@ from lbrynet import conf
|
||||
from lbrynet.lbryfile.StreamDescriptor import get_sd_info
|
||||
from lbrynet.core.cryptoutils import get_lbry_hash_obj
|
||||
from twisted.protocols.basic import FileSender
|
||||
from lbrynet.lbryfilemanager.LBRYFileDownloader import ManagedLBRYFileDownloader
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
@@ -155,4 +154,4 @@ def create_lbry_file(session, lbry_file_manager, file_name, file_handle, key=Non
|
||||
|
||||
d = lbry_file_creator.setup()
|
||||
d.addCallback(lambda _: start_stream())
|
||||
return d
|
||||
return d
|
||||
@@ -27,6 +27,7 @@ class ManagedLBRYFileDownloader(LBRYFileSaver):
|
||||
self.sd_hash = None
|
||||
self.txid = None
|
||||
self.uri = None
|
||||
self.claim_id = None
|
||||
self.rowid = rowid
|
||||
self.lbry_file_manager = lbry_file_manager
|
||||
self.saving_status = False
|
||||
@@ -43,10 +44,16 @@ class ManagedLBRYFileDownloader(LBRYFileSaver):
|
||||
|
||||
return d
|
||||
|
||||
def _save_claim_id(claim_id):
|
||||
self.claim_id = claim_id
|
||||
return defer.succeed(None)
|
||||
|
||||
def _save_claim(name, txid):
|
||||
self.uri = name
|
||||
self.txid = txid
|
||||
return defer.succeed(None)
|
||||
d = self.wallet.get_claimid(name, txid)
|
||||
d.addCallback(_save_claim_id)
|
||||
return d
|
||||
|
||||
d.addCallback(_save_sd_hash)
|
||||
d.addCallback(lambda r: _save_claim(r[0], r[1]) if r else None)
|
||||
|
||||
@@ -80,13 +80,16 @@ class LBRYFileManager(object):
|
||||
d.addCallback(lambda downloader: downloader.restore())
|
||||
return d
|
||||
|
||||
def log_error(err):
|
||||
def log_error(err, rowid, stream_hash, options):
|
||||
log.error("An error occurred while starting a lbry file: %s", err.getErrorMessage())
|
||||
log.error(rowid)
|
||||
log.error(stream_hash)
|
||||
log.error(options)
|
||||
|
||||
def start_lbry_files(lbry_files_and_options):
|
||||
for rowid, stream_hash, options in lbry_files_and_options:
|
||||
d = set_options_and_restore(rowid, stream_hash, options)
|
||||
d.addErrback(log_error)
|
||||
d.addErrback(lambda err: log_error(err, rowid, stream_hash, options))
|
||||
return True
|
||||
|
||||
d = self._get_all_lbry_files()
|
||||
|
||||
@@ -1,18 +1,12 @@
|
||||
import json
|
||||
import logging
|
||||
from time import sleep
|
||||
|
||||
from bitcoinrpc.authproxy import AuthServiceProxy
|
||||
from twisted.internet.task import LoopingCall
|
||||
from zope.interface import implements
|
||||
#from lbrynet.core.StreamDescriptor import PlainStreamDescriptorWriter, BlobStreamDescriptorWriter
|
||||
from lbrynet.core.PaymentRateManager import PaymentRateManager
|
||||
from lbrynet.lbryfilemanager.LBRYFileCreator import create_lbry_file
|
||||
from lbrynet.lbryfilemanager.LBRYFileDownloader import ManagedLBRYFileDownloader
|
||||
# from lbrynet.lbryfile.StreamDescriptor import get_sd_info
|
||||
from lbrynet.lbryfile.StreamDescriptor import publish_sd_blob, create_plain_sd
|
||||
from lbrynet.lbrynet_console.interfaces import ICommandHandler, ICommandHandlerFactory
|
||||
from lbrynet.core.StreamDescriptor import download_sd_blob#, BlobStreamDescriptorReader
|
||||
from lbrynet.core.StreamDescriptor import download_sd_blob
|
||||
from lbrynet.core.Error import UnknownNameError, InvalidBlobHashError, InsufficientFundsError
|
||||
from lbrynet.core.Error import InvalidStreamInfoError
|
||||
from lbrynet.core.utils import is_valid_blobhash
|
||||
|
||||
@@ -1,15 +1,25 @@
|
||||
import binascii
|
||||
import functools
|
||||
import json
|
||||
import unqlite
|
||||
import logging
|
||||
import os
|
||||
|
||||
from twisted.internet import threads, defer
|
||||
import unqlite
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def run_in_thread(fn):
|
||||
@functools.wraps(fn)
|
||||
def wrapped(*args, **kwargs):
|
||||
return threads.deferToThread(fn, *args, **kwargs)
|
||||
return wrapped
|
||||
|
||||
|
||||
class LBRYSettings(object):
|
||||
NAME = "settings.db"
|
||||
def __init__(self, db_dir):
|
||||
self.db_dir = db_dir
|
||||
self.db = None
|
||||
@@ -18,47 +28,39 @@ class LBRYSettings(object):
|
||||
return self._open_db()
|
||||
|
||||
def stop(self):
|
||||
self.db.close()
|
||||
self.db = None
|
||||
return defer.succeed(True)
|
||||
|
||||
def _open_db(self):
|
||||
log.debug("Opening %s as the settings database", str(os.path.join(self.db_dir, "settings.db")))
|
||||
self.db = unqlite.UnQLite(os.path.join(self.db_dir, "settings.db"))
|
||||
filename = os.path.join(self.db_dir, self.NAME)
|
||||
log.debug("Opening %s as the settings database", filename)
|
||||
self.db = unqlite.UnQLite(filename)
|
||||
return defer.succeed(True)
|
||||
|
||||
@run_in_thread
|
||||
def save_lbryid(self, lbryid):
|
||||
self.db['lbryid'] = binascii.hexlify(lbryid)
|
||||
self.db.commit()
|
||||
|
||||
def save_lbryid():
|
||||
self.db['lbryid'] = binascii.hexlify(lbryid)
|
||||
|
||||
return threads.deferToThread(save_lbryid)
|
||||
|
||||
@run_in_thread
|
||||
def get_lbryid(self):
|
||||
if 'lbryid' in self.db:
|
||||
return binascii.unhexlify(self.db['lbryid'])
|
||||
else:
|
||||
return None
|
||||
|
||||
def get_lbryid():
|
||||
if 'lbryid' in self.db:
|
||||
return binascii.unhexlify(self.db['lbryid'])
|
||||
else:
|
||||
return None
|
||||
|
||||
return threads.deferToThread(get_lbryid)
|
||||
|
||||
@run_in_thread
|
||||
def get_server_running_status(self):
|
||||
if 'server_running' in self.db:
|
||||
return json.loads(self.db['server_running'])
|
||||
else:
|
||||
return True
|
||||
|
||||
def get_status():
|
||||
if 'server_running' in self.db:
|
||||
return json.loads(self.db['server_running'])
|
||||
else:
|
||||
return True
|
||||
|
||||
return threads.deferToThread(get_status)
|
||||
|
||||
@run_in_thread
|
||||
def save_server_running_status(self, running):
|
||||
|
||||
def save_status():
|
||||
self.db['server_running'] = json.dumps(running)
|
||||
|
||||
return threads.deferToThread(save_status)
|
||||
self.db['server_running'] = json.dumps(running)
|
||||
self.db.commit()
|
||||
|
||||
def get_default_data_payment_rate(self):
|
||||
return self._get_payment_rate("default_data_payment_rate")
|
||||
@@ -78,35 +80,27 @@ class LBRYSettings(object):
|
||||
def save_server_crypt_info_payment_rate(self, rate):
|
||||
return self._save_payment_rate("server_crypt_info_payment_rate", rate)
|
||||
|
||||
@run_in_thread
|
||||
def _get_payment_rate(self, rate_type):
|
||||
if rate_type in self.db:
|
||||
return json.loads(self.db[rate_type])
|
||||
else:
|
||||
return None
|
||||
|
||||
def get_rate():
|
||||
if rate_type in self.db:
|
||||
return json.loads(self.db[rate_type])
|
||||
else:
|
||||
return None
|
||||
|
||||
return threads.deferToThread(get_rate)
|
||||
|
||||
@run_in_thread
|
||||
def _save_payment_rate(self, rate_type, rate):
|
||||
if rate is not None:
|
||||
self.db[rate_type] = json.dumps(rate)
|
||||
elif rate_type in self.db:
|
||||
del self.db[rate_type]
|
||||
self.db.commit()
|
||||
|
||||
def save_rate():
|
||||
if rate is not None:
|
||||
self.db[rate_type] = json.dumps(rate)
|
||||
elif rate_type in self.db:
|
||||
del self.db[rate_type]
|
||||
|
||||
return threads.deferToThread(save_rate)
|
||||
|
||||
@run_in_thread
|
||||
def get_query_handler_status(self, query_identifier):
|
||||
|
||||
def get_status():
|
||||
if json.dumps(('q_h', query_identifier)) in self.db:
|
||||
return json.loads(self.db[(json.dumps(('q_h', query_identifier)))])
|
||||
else:
|
||||
return True
|
||||
|
||||
return threads.deferToThread(get_status)
|
||||
if json.dumps(('q_h', query_identifier)) in self.db:
|
||||
return json.loads(self.db[(json.dumps(('q_h', query_identifier)))])
|
||||
else:
|
||||
return True
|
||||
|
||||
def enable_query_handler(self, query_identifier):
|
||||
return self._set_query_handler_status(query_identifier, True)
|
||||
@@ -114,7 +108,7 @@ class LBRYSettings(object):
|
||||
def disable_query_handler(self, query_identifier):
|
||||
return self._set_query_handler_status(query_identifier, False)
|
||||
|
||||
@run_in_thread
|
||||
def _set_query_handler_status(self, query_identifier, status):
|
||||
def set_status():
|
||||
self.db[json.dumps(('q_h', query_identifier))] = json.dumps(status)
|
||||
return threads.deferToThread(set_status)
|
||||
self.db[json.dumps(('q_h', query_identifier))] = json.dumps(status)
|
||||
self.db.commit()
|
||||
@@ -1,10 +1,10 @@
|
||||
import sys
|
||||
import json
|
||||
|
||||
from lbrynet.conf import API_CONNECTION_STRING, LOG_FILE_NAME
|
||||
from lbrynet.conf import API_CONNECTION_STRING
|
||||
from jsonrpc.proxy import JSONRPCProxy
|
||||
|
||||
help_msg = "Useage: lbrynet-cli method json-args\n" \
|
||||
help_msg = "Usage: lbrynet-cli method json-args\n" \
|
||||
+ "Examples: " \
|
||||
+ "lbrynet-cli resolve_name '{\"name\": \"what\"}'\n" \
|
||||
+ "lbrynet-cli get_balance\n" \
|
||||
|
||||
@@ -5,17 +5,18 @@ import os
|
||||
import webbrowser
|
||||
import sys
|
||||
import socket
|
||||
import platform
|
||||
from appdirs import user_data_dir
|
||||
|
||||
from twisted.web import server
|
||||
from twisted.internet import reactor, defer
|
||||
from jsonrpc.proxy import JSONRPCProxy
|
||||
|
||||
from lbrynet.lbrynet_daemon.LBRYDaemonServer import LBRYDaemonServer
|
||||
from lbrynet.conf import API_CONNECTION_STRING, API_INTERFACE, API_ADDRESS, API_PORT, \
|
||||
DEFAULT_WALLET, UI_ADDRESS, DEFAULT_UI_BRANCH, LOG_FILE_NAME
|
||||
from lbrynet.core import log_support
|
||||
from lbrynet.lbrynet_daemon.LBRYDaemonServer import LBRYDaemonServer, LBRYDaemonRequest
|
||||
from lbrynet.conf import API_CONNECTION_STRING, API_INTERFACE, API_PORT, \
|
||||
UI_ADDRESS, DEFAULT_UI_BRANCH, LOG_FILE_NAME
|
||||
|
||||
# TODO: stop it!
|
||||
if sys.platform != "darwin":
|
||||
log_dir = os.path.join(os.path.expanduser("~"), ".lbrynet")
|
||||
else:
|
||||
@@ -26,12 +27,13 @@ if not os.path.isdir(log_dir):
|
||||
|
||||
lbrynet_log = os.path.join(log_dir, LOG_FILE_NAME)
|
||||
log = logging.getLogger(__name__)
|
||||
handler = logging.handlers.RotatingFileHandler(lbrynet_log, maxBytes=2097152, backupCount=5)
|
||||
log.addHandler(handler)
|
||||
log.setLevel(logging.INFO)
|
||||
|
||||
|
||||
REMOTE_SERVER = "www.google.com"
|
||||
|
||||
if getattr(sys, 'frozen', False) and os.name == "nt":
|
||||
os.environ["REQUESTS_CA_BUNDLE"] = os.path.join(os.path.dirname(sys.executable), "cacert.pem")
|
||||
|
||||
|
||||
def test_internet_connection():
|
||||
try:
|
||||
@@ -74,10 +76,12 @@ def start():
|
||||
parser.set_defaults(branch=False, launchui=True, logtoconsole=False, quiet=False)
|
||||
args = parser.parse_args()
|
||||
|
||||
log_support.configure_file_handler(lbrynet_log)
|
||||
log_support.configure_loggly_handler()
|
||||
if args.logtoconsole:
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
|
||||
args = parser.parse_args()
|
||||
log_support.configure_console(level='DEBUG')
|
||||
log_support.disable_third_party_loggers()
|
||||
log_support.disable_noisy_loggers()
|
||||
|
||||
try:
|
||||
JSONRPCProxy.from_url(API_CONNECTION_STRING).is_running()
|
||||
@@ -109,7 +113,9 @@ def start():
|
||||
if args.launchui:
|
||||
d.addCallback(lambda _: webbrowser.open(UI_ADDRESS))
|
||||
|
||||
reactor.listenTCP(API_PORT, server.Site(lbry.root), interface=API_INTERFACE)
|
||||
lbrynet_server = server.Site(lbry.root)
|
||||
lbrynet_server.requestFactory = LBRYDaemonRequest
|
||||
reactor.listenTCP(API_PORT, lbrynet_server, interface=API_INTERFACE)
|
||||
reactor.run()
|
||||
|
||||
if not args.logtoconsole and not args.quiet:
|
||||
@@ -121,4 +127,4 @@ def start():
|
||||
return
|
||||
|
||||
if __name__ == "__main__":
|
||||
start()
|
||||
start()
|
||||
@@ -4,18 +4,22 @@ import shutil
|
||||
import json
|
||||
import sys
|
||||
import mimetypes
|
||||
import mimetools
|
||||
import tempfile
|
||||
import time
|
||||
import cgi
|
||||
|
||||
from datetime import datetime
|
||||
from appdirs import user_data_dir
|
||||
from twisted.web import server, static, resource
|
||||
from twisted.internet import defer, interfaces, error, reactor, task, threads
|
||||
from twisted.internet import defer, interfaces, error, reactor, threads
|
||||
|
||||
from zope.interface import implements
|
||||
|
||||
from lbrynet.lbrynet_daemon.LBRYDaemon import LBRYDaemon
|
||||
from lbrynet.conf import API_CONNECTION_STRING, API_ADDRESS, DEFAULT_WALLET, UI_ADDRESS, DEFAULT_UI_BRANCH, LOG_FILE_NAME
|
||||
from lbrynet.conf import API_ADDRESS, UI_ADDRESS, DEFAULT_UI_BRANCH, LOG_FILE_NAME
|
||||
|
||||
|
||||
# TODO: omg, this code is essentially duplicated in LBRYDaemon
|
||||
if sys.platform != "darwin":
|
||||
data_dir = os.path.join(os.path.expanduser("~"), ".lbrynet")
|
||||
else:
|
||||
@@ -25,11 +29,186 @@ if not os.path.isdir(data_dir):
|
||||
|
||||
lbrynet_log = os.path.join(data_dir, LOG_FILE_NAME)
|
||||
log = logging.getLogger(__name__)
|
||||
handler = logging.handlers.RotatingFileHandler(lbrynet_log, maxBytes=2097152, backupCount=5)
|
||||
log.addHandler(handler)
|
||||
log.setLevel(logging.INFO)
|
||||
|
||||
|
||||
class LBRYDaemonRequest(server.Request):
|
||||
"""
|
||||
For LBRY specific request functionality. Currently just provides
|
||||
handling for large multipart POST requests, taken from here:
|
||||
http://sammitch.ca/2013/07/handling-large-requests-in-twisted/
|
||||
|
||||
For multipart POST requests, this populates self.args with temp
|
||||
file objects instead of strings. Note that these files don't auto-delete
|
||||
on close because we want to be able to move and rename them.
|
||||
|
||||
"""
|
||||
|
||||
# max amount of memory to allow any ~single~ request argument [ie: POSTed file]
|
||||
# note: this value seems to be taken with a grain of salt, memory usage may spike
|
||||
# FAR above this value in some cases.
|
||||
# eg: set the memory limit to 5 MB, write 2 blocks of 4MB, mem usage will
|
||||
# have spiked to 8MB before the data is rolled to disk after the
|
||||
# second write completes.
|
||||
memorylimit = 1024*1024*100
|
||||
|
||||
# enable/disable debug logging
|
||||
do_log = False
|
||||
|
||||
# re-defined only for debug/logging purposes
|
||||
def gotLength(self, length):
|
||||
if self.do_log:
|
||||
print '%f Headers received, Content-Length: %d' % (time.time(), length)
|
||||
server.Request.gotLength(self, length)
|
||||
|
||||
# re-definition of twisted.web.server.Request.requestreceived, the only difference
|
||||
# is that self.parse_multipart() is used rather than cgi.parse_multipart()
|
||||
def requestReceived(self, command, path, version):
|
||||
from twisted.web.http import parse_qs
|
||||
if self.do_log:
|
||||
print '%f Request Received' % time.time()
|
||||
|
||||
self.content.seek(0,0)
|
||||
self.args = {}
|
||||
self.stack = []
|
||||
|
||||
self.method, self.uri = command, path
|
||||
self.clientproto = version
|
||||
x = self.uri.split(b'?', 1)
|
||||
|
||||
if len(x) == 1:
|
||||
self.path = self.uri
|
||||
else:
|
||||
self.path, argstring = x
|
||||
self.args = parse_qs(argstring, 1)
|
||||
|
||||
# cache the client and server information, we'll need this later to be
|
||||
# serialized and sent with the request so CGIs will work remotely
|
||||
self.client = self.channel.transport.getPeer()
|
||||
self.host = self.channel.transport.getHost()
|
||||
|
||||
# Argument processing
|
||||
args = self.args
|
||||
ctype = self.requestHeaders.getRawHeaders(b'content-type')
|
||||
if ctype is not None:
|
||||
ctype = ctype[0]
|
||||
|
||||
if self.method == b"POST" and ctype:
|
||||
mfd = b'multipart/form-data'
|
||||
key, pdict = cgi.parse_header(ctype)
|
||||
if key == b'application/x-www-form-urlencoded':
|
||||
args.update(parse_qs(self.content.read(), 1))
|
||||
elif key == mfd:
|
||||
try:
|
||||
self.content.seek(0,0)
|
||||
args.update(self.parse_multipart(self.content, pdict))
|
||||
#args.update(cgi.parse_multipart(self.content, pdict))
|
||||
|
||||
except KeyError as e:
|
||||
if e.args[0] == b'content-disposition':
|
||||
# Parse_multipart can't cope with missing
|
||||
# content-dispostion headers in multipart/form-data
|
||||
# parts, so we catch the exception and tell the client
|
||||
# it was a bad request.
|
||||
self.channel.transport.write(
|
||||
b"HTTP/1.1 400 Bad Request\r\n\r\n")
|
||||
self.channel.transport.loseConnection()
|
||||
return
|
||||
raise
|
||||
|
||||
self.content.seek(0, 0)
|
||||
|
||||
self.process()
|
||||
|
||||
# re-definition of cgi.parse_multipart that uses a single temporary file to store
|
||||
# data rather than storing 2 to 3 copies in various lists.
|
||||
def parse_multipart(self, fp, pdict):
|
||||
if self.do_log:
|
||||
print '%f Parsing Multipart data: ' % time.time()
|
||||
rewind = fp.tell() #save cursor
|
||||
fp.seek(0,0) #reset cursor
|
||||
|
||||
boundary = ""
|
||||
if 'boundary' in pdict:
|
||||
boundary = pdict['boundary']
|
||||
if not cgi.valid_boundary(boundary):
|
||||
raise ValueError, ('Invalid boundary in multipart form: %r'
|
||||
% (boundary,))
|
||||
|
||||
nextpart = "--" + boundary
|
||||
lastpart = "--" + boundary + "--"
|
||||
partdict = {}
|
||||
terminator = ""
|
||||
|
||||
while terminator != lastpart:
|
||||
c_bytes = -1
|
||||
|
||||
data = tempfile.NamedTemporaryFile(delete=False)
|
||||
if terminator:
|
||||
# At start of next part. Read headers first.
|
||||
headers = mimetools.Message(fp)
|
||||
clength = headers.getheader('content-length')
|
||||
if clength:
|
||||
try:
|
||||
c_bytes = int(clength)
|
||||
except ValueError:
|
||||
pass
|
||||
if c_bytes > 0:
|
||||
data.write(fp.read(c_bytes))
|
||||
# Read lines until end of part.
|
||||
while 1:
|
||||
line = fp.readline()
|
||||
if not line:
|
||||
terminator = lastpart # End outer loop
|
||||
break
|
||||
if line[:2] == "--":
|
||||
terminator = line.strip()
|
||||
if terminator in (nextpart, lastpart):
|
||||
break
|
||||
data.write(line)
|
||||
# Done with part.
|
||||
if data.tell() == 0:
|
||||
continue
|
||||
if c_bytes < 0:
|
||||
# if a Content-Length header was not supplied with the MIME part
|
||||
# then the trailing line break must be removed.
|
||||
# we have data, read the last 2 bytes
|
||||
rewind = min(2, data.tell())
|
||||
data.seek(-rewind, os.SEEK_END)
|
||||
line = data.read(2)
|
||||
if line[-2:] == "\r\n":
|
||||
data.seek(-2, os.SEEK_END)
|
||||
data.truncate()
|
||||
elif line[-1:] == "\n":
|
||||
data.seek(-1, os.SEEK_END)
|
||||
data.truncate()
|
||||
|
||||
line = headers['content-disposition']
|
||||
if not line:
|
||||
continue
|
||||
key, params = cgi.parse_header(line)
|
||||
if key != 'form-data':
|
||||
continue
|
||||
if 'name' in params:
|
||||
name = params['name']
|
||||
# kludge in the filename
|
||||
if 'filename' in params:
|
||||
fname_index = name + '_filename'
|
||||
if fname_index in partdict:
|
||||
partdict[fname_index].append(params['filename'])
|
||||
else:
|
||||
partdict[fname_index] = [params['filename']]
|
||||
else:
|
||||
# Unnamed parts are not returned at all.
|
||||
continue
|
||||
data.seek(0,0)
|
||||
if name in partdict:
|
||||
partdict[name].append(data)
|
||||
else:
|
||||
partdict[name] = [data]
|
||||
|
||||
fp.seek(rewind) # Restore cursor
|
||||
return partdict
|
||||
|
||||
class LBRYindex(resource.Resource):
|
||||
def __init__(self, ui_dir):
|
||||
resource.Resource.__init__(self)
|
||||
@@ -47,6 +226,8 @@ class LBRYindex(resource.Resource):
|
||||
return resource.Resource.getChild(self, name, request)
|
||||
|
||||
def render_GET(self, request):
|
||||
request.setHeader('cache-control','no-cache, no-store, must-revalidate')
|
||||
request.setHeader('expires', '0')
|
||||
return static.File(os.path.join(self.ui_dir, "index.html")).render_GET(request)
|
||||
|
||||
|
||||
@@ -74,12 +255,13 @@ class LBRYFileStreamer(object):
|
||||
self._request.setResponseCode(206)
|
||||
self._request.setHeader('accept-ranges', 'bytes')
|
||||
self._request.setHeader('content-type', self._content_type)
|
||||
self._request.setHeader("Content-Security-Policy", "sandbox")
|
||||
|
||||
self.resumeProducing()
|
||||
|
||||
def pauseProducing(self):
|
||||
self._paused = True
|
||||
log.info("[" + str(datetime.now()) + "] Pausing producer")
|
||||
log.info("Pausing producer")
|
||||
return defer.succeed(None)
|
||||
|
||||
def resumeProducing(self):
|
||||
@@ -104,7 +286,7 @@ class LBRYFileStreamer(object):
|
||||
self._request.write(data)
|
||||
self._cursor += 1
|
||||
|
||||
log.info("[" + str(datetime.now()) + "] Wrote range %s-%s/%s, length: %s, readable: %s, depth: %s" %
|
||||
log.info("Wrote range %s-%s/%s, length: %s, readable: %s, depth: %s" %
|
||||
(start_cur, self._cursor, self._file_size, self._cursor - start_cur, readable_bytes, self._depth))
|
||||
self._sent_bytes = True
|
||||
|
||||
@@ -117,12 +299,12 @@ class LBRYFileStreamer(object):
|
||||
self._deferred.addCallback(lambda _: threads.deferToThread(reactor.callLater, self._delay, _check_for_new_data))
|
||||
return defer.succeed(None)
|
||||
|
||||
log.info("[" + str(datetime.now()) + "] Resuming producer")
|
||||
log.info("Resuming producer")
|
||||
self._paused = False
|
||||
self._deferred.addCallback(lambda _: _check_for_new_data())
|
||||
|
||||
def stopProducing(self):
|
||||
log.info("[" + str(datetime.now()) + "] Stopping producer")
|
||||
log.info("Stopping producer")
|
||||
self._stopped = True
|
||||
# self._fileObject.close()
|
||||
self._deferred.addErrback(lambda err: err.trap(defer.CancelledError))
|
||||
@@ -147,7 +329,7 @@ class HostedLBRYFile(resource.Resource):
|
||||
#
|
||||
# range_header = request.getAllHeaders()['range'].replace('bytes=', '').split('-')
|
||||
# start, stop = int(range_header[0]), range_header[1]
|
||||
# log.info("[" + str(datetime.now()) + "] GET range %s-%s" % (start, stop))
|
||||
# log.info("GET range %s-%s" % (start, stop))
|
||||
# path = os.path.join(self._api.download_directory, stream.file_name)
|
||||
#
|
||||
# d = stream.get_total_bytes()
|
||||
@@ -158,6 +340,7 @@ class HostedLBRYFile(resource.Resource):
|
||||
# return d
|
||||
|
||||
def render_GET(self, request):
|
||||
request.setHeader("Content-Security-Policy", "sandbox")
|
||||
if 'name' in request.args.keys():
|
||||
if request.args['name'][0] != 'lbry' and request.args['name'][0] not in self._api.waiting_on.keys():
|
||||
d = self._api._download_name(request.args['name'][0])
|
||||
@@ -179,12 +362,51 @@ class HostedLBRYFile(resource.Resource):
|
||||
# call.addErrback(lambda err: log.info("Error: " + str(err)))
|
||||
# call.cancel()
|
||||
|
||||
class LBRYFileUpload(resource.Resource):
|
||||
"""
|
||||
Accepts a file sent via the file upload widget in the web UI, saves
|
||||
it into a temporary dir, and responds with a JSON string containing
|
||||
the path of the newly created file.
|
||||
"""
|
||||
|
||||
def __init__(self, api):
|
||||
self._api = api
|
||||
|
||||
def render_POST(self, request):
|
||||
origfilename = request.args['file_filename'][0]
|
||||
uploaded_file = request.args['file'][0] # Temp file created by request
|
||||
|
||||
# Move to a new temporary dir and restore the original file name
|
||||
newdirpath = tempfile.mkdtemp()
|
||||
newpath = os.path.join(newdirpath, origfilename)
|
||||
if os.name == "nt":
|
||||
shutil.copy(uploaded_file.name, newpath)
|
||||
# TODO Still need to remove the file
|
||||
|
||||
# TODO deal with pylint error in cleaner fashion than this
|
||||
try:
|
||||
from exceptions import WindowsError as win_except
|
||||
except ImportError as e:
|
||||
log.error("This shouldn't happen")
|
||||
win_except = Exception
|
||||
|
||||
try:
|
||||
os.remove(uploaded_file.name)
|
||||
except win_except as e:
|
||||
pass
|
||||
else:
|
||||
shutil.move(uploaded_file.name, newpath)
|
||||
self._api.uploaded_temp_files.append(newpath)
|
||||
|
||||
return json.dumps(newpath)
|
||||
|
||||
|
||||
class LBRYDaemonServer(object):
|
||||
def _setup_server(self, wallet):
|
||||
self.root = LBRYindex(os.path.join(os.path.join(data_dir, "lbry-ui"), "active"))
|
||||
self._api = LBRYDaemon(self.root, wallet_type=wallet)
|
||||
self.root.putChild("view", HostedLBRYFile(self._api))
|
||||
self.root.putChild("upload", LBRYFileUpload(self._api))
|
||||
self.root.putChild(API_ADDRESS, self._api)
|
||||
return defer.succeed(True)
|
||||
|
||||
|
||||
@@ -3,14 +3,15 @@ import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
from copy import deepcopy
|
||||
from appdirs import user_data_dir
|
||||
from datetime import datetime
|
||||
from twisted.internet import defer
|
||||
from twisted.internet.task import LoopingCall
|
||||
|
||||
from lbrynet.core.Error import InvalidStreamInfoError, InsufficientFundsError
|
||||
from lbrynet.core.Error import InsufficientFundsError, KeyFeeAboveMaxAllowed
|
||||
from lbrynet.core.PaymentRateManager import PaymentRateManager
|
||||
from lbrynet.core.StreamDescriptor import download_sd_blob
|
||||
from lbrynet.metadata.LBRYFee import LBRYFeeValidator
|
||||
from lbrynet.lbryfilemanager.LBRYFileDownloader import ManagedLBRYFileDownloaderFactory
|
||||
from lbrynet.conf import DEFAULT_TIMEOUT, LOG_FILE_NAME
|
||||
|
||||
@@ -37,22 +38,20 @@ if not os.path.isdir(log_dir):
|
||||
|
||||
lbrynet_log = os.path.join(log_dir, LOG_FILE_NAME)
|
||||
log = logging.getLogger(__name__)
|
||||
handler = logging.handlers.RotatingFileHandler(lbrynet_log, maxBytes=2097152, backupCount=5)
|
||||
log.addHandler(handler)
|
||||
log.setLevel(logging.INFO)
|
||||
|
||||
|
||||
class GetStream(object):
|
||||
def __init__(self, sd_identifier, session, wallet, lbry_file_manager, max_key_fee, data_rate=0.5,
|
||||
timeout=DEFAULT_TIMEOUT, download_directory=None, file_name=None):
|
||||
def __init__(self, sd_identifier, session, wallet, lbry_file_manager, exchange_rate_manager,
|
||||
max_key_fee, data_rate=0.5, timeout=DEFAULT_TIMEOUT, download_directory=None, file_name=None):
|
||||
self.wallet = wallet
|
||||
self.resolved_name = None
|
||||
self.description = None
|
||||
self.key_fee = None
|
||||
self.key_fee_address = None
|
||||
self.fee = None
|
||||
self.data_rate = data_rate
|
||||
self.name = None
|
||||
self.file_name = file_name
|
||||
self.session = session
|
||||
self.exchange_rate_manager = exchange_rate_manager
|
||||
self.payment_rate_manager = PaymentRateManager(self.session.base_payment_rate_manager)
|
||||
self.lbry_file_manager = lbry_file_manager
|
||||
self.sd_identifier = sd_identifier
|
||||
@@ -66,49 +65,38 @@ class GetStream(object):
|
||||
self.download_directory = download_directory
|
||||
self.download_path = None
|
||||
self.downloader = None
|
||||
self.finished = defer.Deferred()
|
||||
self.finished = defer.Deferred(None)
|
||||
self.checker = LoopingCall(self.check_status)
|
||||
self.code = STREAM_STAGES[0]
|
||||
|
||||
def check_status(self):
|
||||
self.timeout_counter += 1
|
||||
|
||||
# TODO: Why is this the stopping condition for the finished callback?
|
||||
if self.download_path:
|
||||
self.checker.stop()
|
||||
self.finished.callback((self.stream_hash, self.download_path))
|
||||
self.finished.callback((True, self.stream_hash, self.download_path))
|
||||
|
||||
elif self.timeout_counter >= self.timeout:
|
||||
log.info("Timeout downloading lbry://%s" % self.resolved_name)
|
||||
self.checker.stop()
|
||||
self.d.cancel()
|
||||
self.code = STREAM_STAGES[4]
|
||||
self.finished.callback(False)
|
||||
self.finished.callback((False, None, None))
|
||||
|
||||
def _convert_max_fee(self):
|
||||
if isinstance(self.max_key_fee, dict):
|
||||
max_fee = LBRYFeeValidator(self.max_key_fee)
|
||||
if max_fee.currency_symbol == "LBC":
|
||||
return max_fee.amount
|
||||
return self.exchange_rate_manager.to_lbc(self.fee).amount
|
||||
elif isinstance(self.max_key_fee, float):
|
||||
return float(self.max_key_fee)
|
||||
|
||||
def start(self, stream_info, name):
|
||||
self.resolved_name = name
|
||||
self.stream_info = stream_info
|
||||
if 'sources' in self.stream_info:
|
||||
self.stream_hash = self.stream_info['sources']['lbry_sd_hash']
|
||||
else:
|
||||
raise InvalidStreamInfoError(self.stream_info)
|
||||
if 'description' in self.stream_info:
|
||||
self.description = self.stream_info['description']
|
||||
if 'fee' in self.stream_info:
|
||||
if 'LBC' in self.stream_info['fee']:
|
||||
self.key_fee = float(self.stream_info['fee']['LBC']['amount'])
|
||||
self.key_fee_address = self.stream_info['fee']['LBC']['address']
|
||||
else:
|
||||
self.key_fee_address = None
|
||||
else:
|
||||
self.key_fee = None
|
||||
self.key_fee_address = None
|
||||
if self.key_fee > self.max_key_fee:
|
||||
log.info("Key fee %f above limit of %f didn't download lbry://%s" % (self.key_fee, self.max_key_fee, self.resolved_name))
|
||||
return defer.fail(None)
|
||||
else:
|
||||
pass
|
||||
|
||||
def _cause_timeout():
|
||||
def _cause_timeout(err):
|
||||
log.error(err)
|
||||
log.debug('Forcing a timeout')
|
||||
self.timeout_counter = self.timeout * 2
|
||||
|
||||
def _set_status(x, status):
|
||||
@@ -116,37 +104,64 @@ class GetStream(object):
|
||||
self.code = next(s for s in STREAM_STAGES if s[0] == status)
|
||||
return x
|
||||
|
||||
def get_downloader_factory(metadata):
|
||||
for factory in metadata.factories:
|
||||
if isinstance(factory, ManagedLBRYFileDownloaderFactory):
|
||||
return factory, metadata
|
||||
raise Exception('No suitable factory was found in {}'.format(metadata.factories))
|
||||
|
||||
def make_downloader(args):
|
||||
factory, metadata = args
|
||||
return factory.make_downloader(metadata,
|
||||
[self.data_rate, True],
|
||||
self.payment_rate_manager,
|
||||
download_directory=self.download_directory,
|
||||
file_name=self.file_name)
|
||||
|
||||
self.resolved_name = name
|
||||
self.stream_info = deepcopy(stream_info)
|
||||
self.description = self.stream_info['description']
|
||||
self.stream_hash = self.stream_info['sources']['lbry_sd_hash']
|
||||
|
||||
if 'fee' in self.stream_info:
|
||||
self.fee = LBRYFeeValidator(self.stream_info['fee'])
|
||||
max_key_fee = self._convert_max_fee()
|
||||
if self.exchange_rate_manager.to_lbc(self.fee).amount > max_key_fee:
|
||||
log.info("Key fee %f above limit of %f didn't download lbry://%s" % (self.fee.amount,
|
||||
self.max_key_fee,
|
||||
self.resolved_name))
|
||||
return defer.fail(KeyFeeAboveMaxAllowed())
|
||||
log.info("Key fee %s below limit of %f, downloading lbry://%s" % (json.dumps(self.fee),
|
||||
max_key_fee,
|
||||
self.resolved_name))
|
||||
|
||||
self.checker.start(1)
|
||||
|
||||
self.d.addCallback(lambda _: _set_status(None, DOWNLOAD_METADATA_CODE))
|
||||
self.d.addCallback(lambda _: download_sd_blob(self.session, self.stream_hash, self.payment_rate_manager))
|
||||
self.d.addCallback(self.sd_identifier.get_metadata_for_sd_blob)
|
||||
self.d.addCallback(lambda r: _set_status(r, DOWNLOAD_RUNNING_CODE))
|
||||
self.d.addCallback(lambda metadata: (next(factory for factory in metadata.factories if isinstance(factory, ManagedLBRYFileDownloaderFactory)),
|
||||
metadata))
|
||||
self.d.addCallback(lambda (factory, metadata): factory.make_downloader(metadata,
|
||||
[self.data_rate, True],
|
||||
self.payment_rate_manager,
|
||||
download_directory=self.download_directory,
|
||||
file_name=self.file_name))
|
||||
self.d.addCallbacks(self._start_download, lambda _: _cause_timeout())
|
||||
self.d.addCallback(get_downloader_factory)
|
||||
self.d.addCallback(make_downloader)
|
||||
self.d.addCallbacks(self._start_download, _cause_timeout)
|
||||
self.d.callback(None)
|
||||
|
||||
return self.finished
|
||||
|
||||
def _start_download(self, downloader):
|
||||
def _pay_key_fee():
|
||||
if self.key_fee is not None and self.key_fee_address is not None:
|
||||
reserved_points = self.wallet.reserve_points(self.key_fee_address, self.key_fee)
|
||||
if reserved_points is None:
|
||||
return defer.fail(InsufficientFundsError())
|
||||
log.info("Key fee: %f --> %s" % (self.key_fee, self.key_fee_address))
|
||||
return self.wallet.send_points_to_address(reserved_points, self.key_fee)
|
||||
return defer.succeed(None)
|
||||
|
||||
d = _pay_key_fee()
|
||||
log.info('Starting download for %s', self.name)
|
||||
self.downloader = downloader
|
||||
self.download_path = os.path.join(downloader.download_directory, downloader.file_name)
|
||||
d.addCallback(lambda _: log.info("[%s] Downloading %s --> %s" % (datetime.now(), self.stream_hash, self.downloader.file_name)))
|
||||
|
||||
d = self._pay_key_fee()
|
||||
d.addCallback(lambda _: log.info("Downloading %s --> %s", self.stream_hash, self.downloader.file_name))
|
||||
d.addCallback(lambda _: self.downloader.start())
|
||||
|
||||
def _pay_key_fee(self):
|
||||
if self.fee is not None:
|
||||
fee_lbc = self.exchange_rate_manager.to_lbc(self.fee).amount
|
||||
reserved_points = self.wallet.reserve_points(self.fee.address, fee_lbc)
|
||||
if reserved_points is None:
|
||||
return defer.fail(InsufficientFundsError())
|
||||
return self.wallet.send_points_to_address(reserved_points, fee_lbc)
|
||||
return defer.succeed(None)
|
||||
@@ -0,0 +1,215 @@
|
||||
import time
|
||||
import requests
|
||||
import logging
|
||||
import json
|
||||
import googlefinance
|
||||
from twisted.internet import defer, reactor
|
||||
from twisted.internet.task import LoopingCall
|
||||
|
||||
from lbrynet.metadata.LBRYFee import LBRYFeeValidator
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
CURRENCY_PAIRS = ["USDBTC", "BTCLBC"]
|
||||
BITTREX_FEE = 0.0025
|
||||
COINBASE_FEE = 0.0 #add fee
|
||||
|
||||
|
||||
class ExchangeRate(object):
|
||||
def __init__(self, market, spot, ts):
|
||||
assert int(time.time()) - ts < 600
|
||||
self.currency_pair = (market[0:3], market[3:6])
|
||||
self.spot = spot
|
||||
self.ts = ts
|
||||
|
||||
def as_dict(self):
|
||||
return {'spot': self.spot, 'ts': self.ts}
|
||||
|
||||
|
||||
class MarketFeed(object):
|
||||
def __init__(self, market, name, url, params, fee):
|
||||
self.market = market
|
||||
self.name = name
|
||||
self.url = url
|
||||
self.params = params
|
||||
self.fee = fee
|
||||
self.rate = None
|
||||
self._updater = LoopingCall(self._update_price)
|
||||
|
||||
def _make_request(self):
|
||||
r = requests.get(self.url, self.params)
|
||||
return r.text
|
||||
|
||||
def _handle_response(self, response):
|
||||
return NotImplementedError
|
||||
|
||||
def _subtract_fee(self, from_amount):
|
||||
return defer.succeed(from_amount / (1.0 - self.fee))
|
||||
|
||||
def _save_price(self, price):
|
||||
log.debug("Saving price update %f for %s" % (price, self.market))
|
||||
self.rate = ExchangeRate(self.market, price, int(time.time()))
|
||||
|
||||
def _update_price(self):
|
||||
d = defer.succeed(self._make_request())
|
||||
d.addCallback(self._handle_response)
|
||||
d.addCallback(self._subtract_fee)
|
||||
d.addCallback(self._save_price)
|
||||
|
||||
def start(self):
|
||||
if not self._updater.running:
|
||||
self._updater.start(300)
|
||||
|
||||
def stop(self):
|
||||
if self._updater.running:
|
||||
self._updater.stop()
|
||||
|
||||
|
||||
class BittrexFeed(MarketFeed):
|
||||
def __init__(self):
|
||||
MarketFeed.__init__(
|
||||
self,
|
||||
"BTCLBC",
|
||||
"Bittrex",
|
||||
"https://bittrex.com/api/v1.1/public/getmarkethistory",
|
||||
{'market': 'BTC-LBC', 'count': 50},
|
||||
BITTREX_FEE
|
||||
)
|
||||
|
||||
def _handle_response(self, response):
|
||||
trades = json.loads(response)['result']
|
||||
vwap = sum([i['Total'] for i in trades]) / sum([i['Quantity'] for i in trades])
|
||||
return defer.succeed(float(1.0 / vwap))
|
||||
|
||||
|
||||
class GoogleBTCFeed(MarketFeed):
|
||||
def __init__(self):
|
||||
MarketFeed.__init__(
|
||||
self,
|
||||
"USDBTC",
|
||||
"Coinbase via Google finance",
|
||||
None,
|
||||
None,
|
||||
COINBASE_FEE
|
||||
)
|
||||
|
||||
def _make_request(self):
|
||||
return googlefinance.getQuotes('CURRENCY:USDBTC')[0]
|
||||
|
||||
def _handle_response(self, response):
|
||||
return float(response['LastTradePrice'])
|
||||
|
||||
|
||||
def get_default_market_feed(currency_pair):
|
||||
currencies = None
|
||||
if isinstance(currency_pair, str):
|
||||
currencies = (currency_pair[0:3], currency_pair[3:6])
|
||||
elif isinstance(currency_pair, tuple):
|
||||
currencies = currency_pair
|
||||
assert currencies is not None
|
||||
|
||||
if currencies == ("USD", "BTC"):
|
||||
return GoogleBTCFeed()
|
||||
elif currencies == ("BTC", "LBC"):
|
||||
return BittrexFeed()
|
||||
|
||||
|
||||
class ExchangeRateManager(object):
|
||||
def __init__(self):
|
||||
reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
|
||||
self.market_feeds = [get_default_market_feed(currency_pair) for currency_pair in CURRENCY_PAIRS]
|
||||
|
||||
def start(self):
|
||||
log.info("Starting exchange rate manager")
|
||||
for feed in self.market_feeds:
|
||||
feed.start()
|
||||
|
||||
def stop(self):
|
||||
log.info("Stopping exchange rate manager")
|
||||
for source in self.market_feeds:
|
||||
source.stop()
|
||||
|
||||
def convert_currency(self, from_currency, to_currency, amount):
|
||||
log.info("Converting %f %s to %s" % (amount, from_currency, to_currency))
|
||||
if from_currency == to_currency:
|
||||
return amount
|
||||
for market in self.market_feeds:
|
||||
if market.rate.currency_pair == (from_currency, to_currency):
|
||||
return amount * market.rate.spot
|
||||
for market in self.market_feeds:
|
||||
if market.rate.currency_pair[0] == from_currency:
|
||||
return self.convert_currency(market.rate.currency_pair[1], to_currency, amount * market.rate.spot)
|
||||
raise Exception('Unable to convert {} from {} to {}'.format(amount, from_currency, to_currency))
|
||||
|
||||
def fee_dict(self):
|
||||
return {market: market.rate.as_dict() for market in self.market_feeds}
|
||||
|
||||
def to_lbc(self, fee):
|
||||
if fee is None:
|
||||
return None
|
||||
if not isinstance(fee, LBRYFeeValidator):
|
||||
fee_in = LBRYFeeValidator(fee)
|
||||
else:
|
||||
fee_in = fee
|
||||
|
||||
return LBRYFeeValidator({fee_in.currency_symbol:
|
||||
{
|
||||
'amount': self.convert_currency(fee_in.currency_symbol, "LBC", fee_in.amount),
|
||||
'address': fee_in.address
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
class DummyBTCLBCFeed(MarketFeed):
|
||||
def __init__(self):
|
||||
MarketFeed.__init__(
|
||||
self,
|
||||
"BTCLBC",
|
||||
"market name",
|
||||
"derp.com",
|
||||
None,
|
||||
0.0
|
||||
)
|
||||
|
||||
|
||||
class DummyUSDBTCFeed(MarketFeed):
|
||||
def __init__(self):
|
||||
MarketFeed.__init__(
|
||||
self,
|
||||
"USDBTC",
|
||||
"market name",
|
||||
"derp.com",
|
||||
None,
|
||||
0.0
|
||||
)
|
||||
|
||||
|
||||
class DummyExchangeRateManager(object):
|
||||
def __init__(self, rates):
|
||||
self.market_feeds = [DummyBTCLBCFeed(), DummyUSDBTCFeed()]
|
||||
for feed in self.market_feeds:
|
||||
feed.rate = ExchangeRate(feed.market, rates[feed.market]['spot'], rates[feed.market]['ts'])
|
||||
|
||||
def convert_currency(self, from_currency, to_currency, amount):
|
||||
log.debug("Converting %f %s to %s" % (amount, from_currency, to_currency))
|
||||
for market in self.market_feeds:
|
||||
if market.rate.currency_pair == (from_currency, to_currency):
|
||||
return amount * market.rate.spot
|
||||
for market in self.market_feeds:
|
||||
if market.rate.currency_pair[0] == from_currency:
|
||||
return self.convert_currency(market.rate.currency_pair[1], to_currency, amount * market.rate.spot)
|
||||
|
||||
def to_lbc(self, fee):
|
||||
if fee is None:
|
||||
return None
|
||||
if not isinstance(fee, LBRYFeeValidator):
|
||||
fee_in = LBRYFeeValidator(fee)
|
||||
else:
|
||||
fee_in = fee
|
||||
|
||||
return LBRYFeeValidator({fee_in.currency_symbol:
|
||||
{
|
||||
'amount': self.convert_currency(fee_in.currency_symbol, "LBC", fee_in.amount),
|
||||
'address': fee_in.address
|
||||
}
|
||||
})
|
||||
@@ -2,17 +2,19 @@ import logging
|
||||
import mimetypes
|
||||
import os
|
||||
import sys
|
||||
import random
|
||||
|
||||
from appdirs import user_data_dir
|
||||
from datetime import datetime
|
||||
|
||||
from lbrynet.core.Error import InsufficientFundsError
|
||||
from lbrynet.lbryfilemanager.LBRYFileCreator import create_lbry_file
|
||||
from lbrynet.lbryfile.StreamDescriptor import publish_sd_blob
|
||||
from lbrynet.core.PaymentRateManager import PaymentRateManager
|
||||
from lbrynet.metadata.LBRYMetadata import Metadata
|
||||
from lbrynet.lbryfilemanager.LBRYFileDownloader import ManagedLBRYFileDownloader
|
||||
from lbrynet.conf import LOG_FILE_NAME
|
||||
from twisted.internet import threads, defer
|
||||
from lbrynet import reflector
|
||||
from lbrynet.conf import LOG_FILE_NAME, REFLECTOR_SERVERS
|
||||
from twisted.internet import threads, defer, reactor
|
||||
|
||||
if sys.platform != "darwin":
|
||||
log_dir = os.path.join(os.path.expanduser("~"), ".lbrynet")
|
||||
@@ -24,9 +26,6 @@ if not os.path.isdir(log_dir):
|
||||
|
||||
lbrynet_log = os.path.join(log_dir, LOG_FILE_NAME)
|
||||
log = logging.getLogger(__name__)
|
||||
handler = logging.handlers.RotatingFileHandler(lbrynet_log, maxBytes=2097152, backupCount=5)
|
||||
log.addHandler(handler)
|
||||
log.setLevel(logging.INFO)
|
||||
|
||||
|
||||
class Publisher(object):
|
||||
@@ -42,33 +41,53 @@ class Publisher(object):
|
||||
self.verified = False
|
||||
self.lbry_file = None
|
||||
self.txid = None
|
||||
self.sources = {}
|
||||
self.fee = None
|
||||
|
||||
def start(self, name, file_path, bid, metadata, fee=None, sources={}):
|
||||
self.stream_hash = None
|
||||
reflector_server = random.choice(REFLECTOR_SERVERS)
|
||||
self.reflector_server, self.reflector_port = reflector_server[0], reflector_server[1]
|
||||
self.metadata = {}
|
||||
|
||||
def start(self, name, file_path, bid, metadata):
|
||||
log.info('Starting publish for %s', name)
|
||||
def _show_result():
|
||||
|
||||
message = "[%s] Published %s --> lbry://%s txid: %s" % (datetime.now(), self.file_name, self.publish_name, self.txid)
|
||||
log.info(message)
|
||||
log.info("Success! Published %s --> lbry://%s txid: %s", self.file_name, self.publish_name, self.txid)
|
||||
return defer.succeed(self.txid)
|
||||
|
||||
self.publish_name = name
|
||||
self.file_path = file_path
|
||||
self.bid_amount = bid
|
||||
self.fee = fee
|
||||
self.metadata = metadata
|
||||
|
||||
if os.name == "nt":
|
||||
file_mode = 'rb'
|
||||
else:
|
||||
file_mode = 'r'
|
||||
|
||||
d = self._check_file_path(self.file_path)
|
||||
d.addCallback(lambda _: create_lbry_file(self.session, self.lbry_file_manager,
|
||||
self.file_name, open(self.file_path)))
|
||||
self.file_name, open(self.file_path, file_mode)))
|
||||
d.addCallback(self.add_to_lbry_files)
|
||||
d.addCallback(lambda _: self._create_sd_blob())
|
||||
d.addCallback(lambda _: self._claim_name())
|
||||
d.addCallback(lambda _: self.set_status())
|
||||
d.addCallback(lambda _: self.start_reflector())
|
||||
d.addCallbacks(lambda _: _show_result(), self._show_publish_error)
|
||||
|
||||
return d
|
||||
|
||||
def start_reflector(self):
|
||||
reflector_server = random.choice(REFLECTOR_SERVERS)
|
||||
reflector_address, reflector_port = reflector_server[0], reflector_server[1]
|
||||
log.info("Reflecting new publication")
|
||||
factory = reflector.ClientFactory(
|
||||
self.session.blob_manager,
|
||||
self.lbry_file_manager.stream_info_manager,
|
||||
self.stream_hash
|
||||
)
|
||||
d = reactor.resolve(reflector_address)
|
||||
d.addCallback(lambda ip: reactor.connectTCP(ip, reflector_port, factory))
|
||||
d.addCallback(lambda _: factory.finished_deferred)
|
||||
return d
|
||||
|
||||
def _check_file_path(self, file_path):
|
||||
def check_file_threaded():
|
||||
f = open(file_path)
|
||||
@@ -77,52 +96,56 @@ class Publisher(object):
|
||||
return True
|
||||
return threads.deferToThread(check_file_threaded)
|
||||
|
||||
def _get_new_address(self):
|
||||
d = self.wallet.get_new_address()
|
||||
|
||||
def set_address(address):
|
||||
self.key_fee_address = address
|
||||
return True
|
||||
|
||||
d.addCallback(set_address)
|
||||
return d
|
||||
|
||||
def set_status(self, lbry_file_downloader):
|
||||
def set_lbry_file(self, lbry_file_downloader):
|
||||
self.lbry_file = lbry_file_downloader
|
||||
d = self.lbry_file_manager.change_lbry_file_status(self.lbry_file, ManagedLBRYFileDownloader.STATUS_FINISHED)
|
||||
d.addCallback(lambda _: lbry_file_downloader.restore())
|
||||
return d
|
||||
return defer.succeed(None)
|
||||
|
||||
def add_to_lbry_files(self, stream_hash):
|
||||
self.stream_hash = stream_hash
|
||||
prm = PaymentRateManager(self.session.base_payment_rate_manager)
|
||||
d = self.lbry_file_manager.add_lbry_file(stream_hash, prm)
|
||||
d.addCallback(self.set_status)
|
||||
d.addCallback(self.set_lbry_file)
|
||||
return d
|
||||
|
||||
def _create_sd_blob(self):
|
||||
d = publish_sd_blob(self.lbry_file_manager.stream_info_manager, self.session.blob_manager,
|
||||
log.debug('Creating stream descriptor blob')
|
||||
d = publish_sd_blob(self.lbry_file_manager.stream_info_manager,
|
||||
self.session.blob_manager,
|
||||
self.lbry_file.stream_hash)
|
||||
|
||||
def set_sd_hash(sd_hash):
|
||||
self.sources['lbry_sd_hash'] = sd_hash
|
||||
log.debug('stream descriptor hash: %s', sd_hash)
|
||||
if 'sources' not in self.metadata:
|
||||
self.metadata['sources'] = {}
|
||||
self.metadata['sources']['lbry_sd_hash'] = sd_hash
|
||||
|
||||
d.addCallback(set_sd_hash)
|
||||
return d
|
||||
|
||||
def set_status(self):
|
||||
log.debug('Setting status')
|
||||
d = self.lbry_file_manager.change_lbry_file_status(self.lbry_file, ManagedLBRYFileDownloader.STATUS_FINISHED)
|
||||
d.addCallback(lambda _: self.lbry_file.restore())
|
||||
return d
|
||||
|
||||
def _claim_name(self):
|
||||
self.metadata['content-type'] = mimetypes.guess_type(os.path.join(self.lbry_file.download_directory,
|
||||
self.lbry_file.file_name))[0]
|
||||
d = self.wallet.claim_name(self.publish_name,
|
||||
self.bid_amount,
|
||||
self.sources,
|
||||
self.metadata,
|
||||
fee=self.fee)
|
||||
log.debug('Claiming name')
|
||||
self._update_metadata()
|
||||
m = Metadata(self.metadata)
|
||||
|
||||
def set_tx_hash(txid):
|
||||
log.debug('Name claimed using txid: %s', txid)
|
||||
self.txid = txid
|
||||
|
||||
d = self.wallet.claim_name(self.publish_name, self.bid_amount, m)
|
||||
d.addCallback(set_tx_hash)
|
||||
return d
|
||||
|
||||
def _update_metadata(self):
|
||||
filename = os.path.join(self.lbry_file.download_directory, self.lbry_file.file_name)
|
||||
self.metadata['content_type'] = get_content_type(filename)
|
||||
self.metadata['ver'] = Metadata.current_version
|
||||
|
||||
def _show_publish_error(self, err):
|
||||
log.info(err.getTraceback())
|
||||
message = "An error occurred publishing %s to %s. Error: %s."
|
||||
@@ -134,4 +157,8 @@ class Publisher(object):
|
||||
log.error(error_message)
|
||||
log.error(message, str(self.file_name), str(self.publish_name), err.getTraceback())
|
||||
|
||||
return defer.succeed(error_message)
|
||||
return defer.fail(Exception("Publish failed"))
|
||||
|
||||
|
||||
def get_content_type(filename):
|
||||
return mimetypes.guess_type(filename)[0]
|
||||
@@ -25,9 +25,6 @@ if not os.path.isdir(log_dir):
|
||||
|
||||
lbrynet_log = os.path.join(log_dir, LOG_FILE_NAME)
|
||||
log = logging.getLogger(__name__)
|
||||
handler = logging.handlers.RotatingFileHandler(lbrynet_log, maxBytes=2097152, backupCount=5)
|
||||
log.addHandler(handler)
|
||||
log.setLevel(logging.INFO)
|
||||
|
||||
|
||||
class LBRYUIManager(object):
|
||||
@@ -98,8 +95,8 @@ class LBRYUIManager(object):
|
||||
return d
|
||||
else:
|
||||
log.info("Checking for updates for UI branch: " + branch)
|
||||
self._git_url = "https://api.github.com/repos/lbryio/lbry-web-ui/git/refs/heads/%s" % branch
|
||||
self._dist_url = "https://raw.githubusercontent.com/lbryio/lbry-web-ui/%s/dist.zip" % branch
|
||||
self._git_url = "https://s3.amazonaws.com/lbry-ui/{}/data.json".format(branch)
|
||||
self._dist_url = "https://s3.amazonaws.com/lbry-ui/{}/dist.zip".format(branch)
|
||||
|
||||
d = self._up_to_date()
|
||||
d.addCallback(lambda r: self._download_ui() if not r else self._load_ui())
|
||||
@@ -109,7 +106,7 @@ class LBRYUIManager(object):
|
||||
def _get_git_info():
|
||||
response = urlopen(self._git_url)
|
||||
data = json.loads(response.read())
|
||||
return defer.succeed(data['object']['sha'])
|
||||
return defer.succeed(data['sha'])
|
||||
|
||||
def _set_git(version):
|
||||
self.git_version = version.replace('\n', '')
|
||||
@@ -239,4 +236,4 @@ class LBRYUIManager(object):
|
||||
def _load_ui(self):
|
||||
for d in [i[0] for i in os.walk(self.active_dir) if os.path.dirname(i[0]) == self.active_dir]:
|
||||
self.root.putChild(os.path.basename(d), static.File(d))
|
||||
return defer.succeed(True)
|
||||
return defer.succeed(True)
|
||||
@@ -0,0 +1,27 @@
|
||||
import logging
|
||||
import random
|
||||
from txjsonrpc.web.jsonrpc import Proxy
|
||||
from lbrynet.conf import SEARCH_SERVERS
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class LighthouseClient(object):
|
||||
def __init__(self, servers=None):
|
||||
self.servers = servers or SEARCH_SERVERS
|
||||
|
||||
def _get_random_server(self):
|
||||
return Proxy(random.choice(self.servers))
|
||||
|
||||
def _run_query(self, func, arg):
|
||||
return self._get_random_server().callRemote(func, arg)
|
||||
|
||||
def search(self, search):
|
||||
return self._run_query('search', search)
|
||||
|
||||
def announce_sd(self, sd_hash):
|
||||
log.info("Announce sd to lighthouse")
|
||||
return self._run_query('announce_sd', sd_hash)
|
||||
|
||||
def check_available(self, sd_hash):
|
||||
return self._run_query('check_available', sd_hash)
|
||||
@@ -0,0 +1,116 @@
|
||||
import logging
|
||||
|
||||
from lbrynet.metadata.Validator import Validator, skip_validate
|
||||
from lbrynet.conf import CURRENCIES
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def verify_supported_currency(fee):
|
||||
assert len(fee) == 1
|
||||
for c in fee:
|
||||
assert c in CURRENCIES
|
||||
return True
|
||||
|
||||
|
||||
def verify_amount(x):
|
||||
return isinstance(x, float) or isinstance(x, int) and x > 0
|
||||
|
||||
|
||||
class LBCFeeValidator(Validator):
|
||||
FV001 = "0.0.1"
|
||||
CURRENT_FEE_VERSION = FV001
|
||||
|
||||
FEE_REVISIONS = {}
|
||||
|
||||
FEE_REVISIONS[FV001] = [
|
||||
(Validator.REQUIRE, 'amount', verify_amount),
|
||||
(Validator.REQUIRE, 'address', skip_validate),
|
||||
]
|
||||
|
||||
FEE_MIGRATIONS = []
|
||||
|
||||
current_version = CURRENT_FEE_VERSION
|
||||
versions = FEE_REVISIONS
|
||||
migrations = FEE_MIGRATIONS
|
||||
|
||||
def __init__(self, fee):
|
||||
Validator.__init__(self, fee)
|
||||
|
||||
|
||||
class BTCFeeValidator(Validator):
|
||||
FV001 = "0.0.1"
|
||||
CURRENT_FEE_VERSION = FV001
|
||||
|
||||
FEE_REVISIONS = {}
|
||||
|
||||
FEE_REVISIONS[FV001] = [
|
||||
(Validator.REQUIRE, 'amount',verify_amount),
|
||||
(Validator.REQUIRE, 'address', skip_validate),
|
||||
]
|
||||
|
||||
FEE_MIGRATIONS = []
|
||||
|
||||
current_version = CURRENT_FEE_VERSION
|
||||
versions = FEE_REVISIONS
|
||||
migrations = FEE_MIGRATIONS
|
||||
|
||||
def __init__(self, fee):
|
||||
Validator.__init__(self, fee)
|
||||
|
||||
|
||||
class USDFeeValidator(Validator):
|
||||
FV001 = "0.0.1"
|
||||
CURRENT_FEE_VERSION = FV001
|
||||
|
||||
FEE_REVISIONS = {}
|
||||
|
||||
FEE_REVISIONS[FV001] = [
|
||||
(Validator.REQUIRE, 'amount',verify_amount),
|
||||
(Validator.REQUIRE, 'address', skip_validate),
|
||||
]
|
||||
|
||||
FEE_MIGRATIONS = []
|
||||
|
||||
current_version = CURRENT_FEE_VERSION
|
||||
versions = FEE_REVISIONS
|
||||
migrations = FEE_MIGRATIONS
|
||||
|
||||
def __init__(self, fee):
|
||||
Validator.__init__(self, fee)
|
||||
|
||||
|
||||
class LBRYFeeValidator(Validator):
|
||||
CV001 = "0.0.1"
|
||||
CURRENT_CURRENCY_VERSION = CV001
|
||||
|
||||
CURRENCY_REVISIONS = {}
|
||||
|
||||
CURRENCY_REVISIONS[CV001] = [
|
||||
(Validator.OPTIONAL, 'BTC', BTCFeeValidator.validate),
|
||||
(Validator.OPTIONAL, 'USD', USDFeeValidator.validate),
|
||||
(Validator.OPTIONAL, 'LBC', LBCFeeValidator.validate),
|
||||
]
|
||||
|
||||
CURRENCY_MIGRATIONS = []
|
||||
|
||||
current_version = CURRENT_CURRENCY_VERSION
|
||||
versions = CURRENCY_REVISIONS
|
||||
migrations = CURRENCY_MIGRATIONS
|
||||
|
||||
def __init__(self, fee_dict):
|
||||
Validator.__init__(self, fee_dict)
|
||||
self.currency_symbol = self.keys()[0]
|
||||
self.amount = self._get_amount()
|
||||
self.address = self[self.currency_symbol]['address']
|
||||
|
||||
def _get_amount(self):
|
||||
amt = self[self.currency_symbol]['amount']
|
||||
if isinstance(amt, float):
|
||||
return amt
|
||||
else:
|
||||
try:
|
||||
return float(amt)
|
||||
except TypeError:
|
||||
log.error('Failed to convert %s to float', amt)
|
||||
raise
|
||||
@@ -0,0 +1,86 @@
|
||||
import logging
|
||||
|
||||
from lbrynet.metadata.Validator import Validator, skip_validate
|
||||
from lbrynet.metadata.LBRYFee import LBRYFeeValidator, verify_supported_currency
|
||||
from lbrynet.conf import SOURCE_TYPES
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
NAME_ALLOWED_CHARSET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0987654321-'
|
||||
|
||||
|
||||
def verify_name_characters(name):
|
||||
for c in name:
|
||||
assert c in NAME_ALLOWED_CHARSET, "Invalid character"
|
||||
return True
|
||||
|
||||
|
||||
def validate_sources(sources):
|
||||
for source in sources:
|
||||
assert source in SOURCE_TYPES, "Unknown source type: %s" % str(source)
|
||||
return True
|
||||
|
||||
|
||||
class Metadata(Validator):
|
||||
MV001 = "0.0.1"
|
||||
MV002 = "0.0.2"
|
||||
MV003 = "0.0.3"
|
||||
CURRENT_METADATA_VERSION = MV003
|
||||
|
||||
METADATA_REVISIONS = {}
|
||||
|
||||
METADATA_REVISIONS[MV001] = [
|
||||
(Validator.REQUIRE, 'title', skip_validate),
|
||||
(Validator.REQUIRE, 'description', skip_validate),
|
||||
(Validator.REQUIRE, 'author', skip_validate),
|
||||
(Validator.REQUIRE, 'language', skip_validate),
|
||||
(Validator.REQUIRE, 'license', skip_validate),
|
||||
(Validator.REQUIRE, 'content-type', skip_validate),
|
||||
(Validator.REQUIRE, 'sources', validate_sources),
|
||||
(Validator.OPTIONAL, 'thumbnail', skip_validate),
|
||||
(Validator.OPTIONAL, 'preview', skip_validate),
|
||||
(Validator.OPTIONAL, 'fee', verify_supported_currency),
|
||||
(Validator.OPTIONAL, 'contact', skip_validate),
|
||||
(Validator.OPTIONAL, 'pubkey', skip_validate),
|
||||
]
|
||||
|
||||
METADATA_REVISIONS[MV002] = [
|
||||
(Validator.REQUIRE, 'nsfw', skip_validate),
|
||||
(Validator.REQUIRE, 'ver', skip_validate),
|
||||
(Validator.OPTIONAL, 'license_url', skip_validate),
|
||||
]
|
||||
|
||||
METADATA_REVISIONS[MV003] = [
|
||||
(Validator.REQUIRE, 'content_type', skip_validate),
|
||||
(Validator.SKIP, 'content-type'),
|
||||
(Validator.OPTIONAL, 'sig', skip_validate),
|
||||
(Validator.IF_KEY, 'sig', (Validator.REQUIRE, 'pubkey', skip_validate), Validator.DO_NOTHING),
|
||||
(Validator.IF_KEY, 'pubkey', (Validator.REQUIRE, 'sig', skip_validate), Validator.DO_NOTHING),
|
||||
]
|
||||
|
||||
MIGRATE_MV001_TO_MV002 = [
|
||||
(Validator.IF_KEY, 'nsfw', Validator.DO_NOTHING, (Validator.LOAD, 'nsfw', False)),
|
||||
(Validator.IF_KEY, 'ver', Validator.DO_NOTHING, (Validator.LOAD, 'ver', MV002)),
|
||||
]
|
||||
|
||||
MIGRATE_MV002_TO_MV003 = [
|
||||
(Validator.IF_KEY, 'content-type', (Validator.UPDATE, 'content-type', 'content_type'), Validator.DO_NOTHING),
|
||||
(Validator.IF_VAL, 'ver', MV002, (Validator.LOAD, 'ver', MV003), Validator.DO_NOTHING),
|
||||
]
|
||||
|
||||
METADATA_MIGRATIONS = [
|
||||
MIGRATE_MV001_TO_MV002,
|
||||
MIGRATE_MV002_TO_MV003,
|
||||
]
|
||||
|
||||
current_version = CURRENT_METADATA_VERSION
|
||||
versions = METADATA_REVISIONS
|
||||
migrations = METADATA_MIGRATIONS
|
||||
|
||||
def __init__(self, metadata, process_now=True):
|
||||
Validator.__init__(self, metadata, process_now)
|
||||
self.meta_version = self.get('ver', Metadata.MV001)
|
||||
self._load_fee()
|
||||
|
||||
def _load_fee(self):
|
||||
if 'fee' in self:
|
||||
self.update({'fee': LBRYFeeValidator(self['fee'])})
|
||||
@@ -0,0 +1,155 @@
|
||||
import json
|
||||
import logging
|
||||
from copy import deepcopy
|
||||
from distutils.version import StrictVersion
|
||||
from lbrynet.core.utils import version_is_greater_than
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def skip_validate(value):
|
||||
return True
|
||||
|
||||
|
||||
def processor(cls):
|
||||
for methodname in dir(cls):
|
||||
method = getattr(cls, methodname)
|
||||
if hasattr(method, 'cmd_name'):
|
||||
cls.commands.update({method.cmd_name: methodname})
|
||||
return cls
|
||||
|
||||
|
||||
def cmd(cmd_name):
|
||||
def wrapper(func):
|
||||
func.cmd_name = cmd_name
|
||||
return func
|
||||
return wrapper
|
||||
|
||||
|
||||
@processor
|
||||
class Validator(dict):
|
||||
"""
|
||||
Base class for validated dictionaries
|
||||
"""
|
||||
|
||||
# override these
|
||||
current_version = None
|
||||
versions = {}
|
||||
migrations = []
|
||||
|
||||
# built in commands
|
||||
DO_NOTHING = "do_nothing"
|
||||
UPDATE = "update_key"
|
||||
IF_KEY = "if_key"
|
||||
REQUIRE = "require"
|
||||
SKIP = "skip"
|
||||
OPTIONAL = "optional"
|
||||
LOAD = "load"
|
||||
IF_VAL = "if_val"
|
||||
|
||||
commands = {}
|
||||
|
||||
@classmethod
|
||||
def load_from_hex(cls, hex_val):
|
||||
return cls(json.loads(hex_val.decode('hex')))
|
||||
|
||||
@classmethod
|
||||
def validate(cls, value):
|
||||
if cls(value):
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def __init__(self, value, process_now=False):
|
||||
dict.__init__(self)
|
||||
self._skip = []
|
||||
value_to_load = deepcopy(value)
|
||||
if process_now:
|
||||
self.process(value_to_load)
|
||||
self._verify_value(value_to_load)
|
||||
self.version = self.get('ver', "0.0.1")
|
||||
|
||||
def process(self, value):
|
||||
if self.migrations is not None:
|
||||
self._migrate_value(value)
|
||||
|
||||
@cmd(DO_NOTHING)
|
||||
def _do_nothing(self):
|
||||
pass
|
||||
|
||||
@cmd(SKIP)
|
||||
def _add_to_skipped(self, rx_value, key):
|
||||
if key not in self._skip:
|
||||
self._skip.append(key)
|
||||
|
||||
@cmd(UPDATE)
|
||||
def _update(self, rx_value, old_key, new_key):
|
||||
rx_value.update({new_key: rx_value.pop(old_key)})
|
||||
|
||||
@cmd(IF_KEY)
|
||||
def _if_key(self, rx_value, key, if_true, if_else):
|
||||
if key in rx_value:
|
||||
return self._handle(if_true, rx_value)
|
||||
return self._handle(if_else, rx_value)
|
||||
|
||||
@cmd(IF_VAL)
|
||||
def _if_val(self, rx_value, key, val, if_true, if_else):
|
||||
if key in rx_value:
|
||||
if rx_value[key] == val:
|
||||
return self._handle(if_true, rx_value)
|
||||
return self._handle(if_else, rx_value)
|
||||
|
||||
@cmd(LOAD)
|
||||
def _load(self, rx_value, key, value):
|
||||
rx_value.update({key: value})
|
||||
|
||||
@cmd(REQUIRE)
|
||||
def _require(self, rx_value, key, validator=None):
|
||||
if key not in self._skip:
|
||||
assert key in rx_value, "Key is missing: %s" % key
|
||||
if isinstance(validator, type):
|
||||
assert isinstance(rx_value[key], validator), "%s: %s isn't required %s" % (key, type(rx_value[key]), validator)
|
||||
elif callable(validator):
|
||||
assert validator(rx_value[key]), "Failed to validate %s" % key
|
||||
self.update({key: rx_value.pop(key)})
|
||||
|
||||
@cmd(OPTIONAL)
|
||||
def _optional(self, rx_value, key, validator=None):
|
||||
if key in rx_value and key not in self._skip:
|
||||
if isinstance(validator, type):
|
||||
assert isinstance(rx_value[key], validator), "%s type %s isn't required %s" % (key, type(rx_value[key]), validator)
|
||||
elif callable(validator):
|
||||
assert validator(rx_value[key]), "Failed to validate %s" % key
|
||||
self.update({key: rx_value.pop(key)})
|
||||
|
||||
def _handle(self, cmd_tpl, value):
|
||||
if cmd_tpl == Validator.DO_NOTHING:
|
||||
return
|
||||
command = cmd_tpl[0]
|
||||
f = getattr(self, self.commands[command])
|
||||
if len(cmd_tpl) > 1:
|
||||
args = (value,) + cmd_tpl[1:]
|
||||
f(*args)
|
||||
else:
|
||||
f()
|
||||
|
||||
def _load_revision(self, version, value):
|
||||
for k in self.versions[version]:
|
||||
self._handle(k, value)
|
||||
|
||||
def _verify_value(self, value):
|
||||
val_ver = value.get('ver', "0.0.1")
|
||||
# verify version requirements in reverse order starting from the version asserted in the value
|
||||
versions = sorted([v for v in self.versions if not version_is_greater_than(v, val_ver)], key=StrictVersion, reverse=True)
|
||||
for version in versions:
|
||||
self._load_revision(version, value)
|
||||
assert value == {} or value.keys() == self._skip, "Unknown keys: %s" % json.dumps(value)
|
||||
|
||||
def _migrate_value(self, value):
|
||||
for migration in self.migrations:
|
||||
self._run_migration(migration, value)
|
||||
|
||||
def _run_migration(self, commands, value):
|
||||
for cmd in commands:
|
||||
self._handle(cmd, value)
|
||||
|
||||
@@ -6,7 +6,6 @@ CLI for sending rpc commands to a DHT node
|
||||
from twisted.internet import reactor
|
||||
from txjsonrpc.web.jsonrpc import Proxy
|
||||
import argparse
|
||||
import sys
|
||||
|
||||
|
||||
def print_value(value):
|
||||
@@ -39,4 +38,4 @@ def main():
|
||||
d = proxy.callRemote(args.rpc_command)
|
||||
d.addCallbacks(print_value, print_error)
|
||||
d.addBoth(lambda _: shut_down())
|
||||
reactor.run()
|
||||
reactor.run()
|
||||
@@ -0,0 +1,3 @@
|
||||
from lbrynet.reflector.server.server import ReflectorServerFactory as ServerFactory
|
||||
from lbrynet.reflector.client.client import LBRYFileReflectorClientFactory as ClientFactory
|
||||
from lbrynet.reflector.client.client import LBRYBlobReflectorClientFactory as BlobClientFactory
|
||||
@@ -0,0 +1,454 @@
|
||||
"""
|
||||
The reflector protocol (all dicts encoded in json):
|
||||
|
||||
Client Handshake (sent once per connection, at the start of the connection):
|
||||
|
||||
{
|
||||
'version': 0,
|
||||
}
|
||||
|
||||
|
||||
Server Handshake (sent once per connection, after receiving the client handshake):
|
||||
|
||||
{
|
||||
'version': 0,
|
||||
}
|
||||
|
||||
|
||||
Client Info Request:
|
||||
|
||||
{
|
||||
'blob_hash': "<blob_hash>",
|
||||
'blob_size': <blob_size>
|
||||
}
|
||||
|
||||
|
||||
Server Info Response (sent in response to Client Info Request):
|
||||
|
||||
{
|
||||
'send_blob': True|False
|
||||
}
|
||||
|
||||
If response is 'YES', client may send a Client Blob Request or a Client Info Request.
|
||||
If response is 'NO', client may only send a Client Info Request
|
||||
|
||||
|
||||
Client Blob Request:
|
||||
|
||||
{} # Yes, this is an empty dictionary, in case something needs to go here in the future
|
||||
<raw blob_data> # this blob data must match the info sent in the most recent Client Info Request
|
||||
|
||||
|
||||
Server Blob Response (sent in response to Client Blob Request):
|
||||
{
|
||||
'received_blob': True
|
||||
}
|
||||
|
||||
Client may now send another Client Info Request
|
||||
|
||||
"""
|
||||
import json
|
||||
import logging
|
||||
from twisted.protocols.basic import FileSender
|
||||
from twisted.internet.protocol import Protocol, ClientFactory
|
||||
from twisted.internet import defer, error
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class IncompleteResponseError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class LBRYFileReflectorClient(Protocol):
|
||||
|
||||
# Protocol stuff
|
||||
|
||||
def connectionMade(self):
|
||||
self.blob_manager = self.factory.blob_manager
|
||||
self.response_buff = ''
|
||||
self.outgoing_buff = ''
|
||||
self.blob_hashes_to_send = []
|
||||
self.next_blob_to_send = None
|
||||
self.blob_read_handle = None
|
||||
self.received_handshake_response = False
|
||||
self.protocol_version = None
|
||||
self.file_sender = None
|
||||
self.producer = None
|
||||
self.streaming = False
|
||||
d = self.get_blobs_to_send(self.factory.stream_info_manager, self.factory.stream_hash)
|
||||
d.addCallback(lambda _: self.send_handshake())
|
||||
d.addErrback(lambda err: log.warning("An error occurred immediately: %s", err.getTraceback()))
|
||||
|
||||
def dataReceived(self, data):
|
||||
log.debug('Recieved %s', data)
|
||||
self.response_buff += data
|
||||
try:
|
||||
msg = self.parse_response(self.response_buff)
|
||||
except IncompleteResponseError:
|
||||
pass
|
||||
else:
|
||||
self.response_buff = ''
|
||||
d = self.handle_response(msg)
|
||||
d.addCallback(lambda _: self.send_next_request())
|
||||
d.addErrback(self.response_failure_handler)
|
||||
|
||||
def connectionLost(self, reason):
|
||||
if reason.check(error.ConnectionDone):
|
||||
log.debug('Finished sending data via reflector')
|
||||
self.factory.finished_deferred.callback(True)
|
||||
else:
|
||||
log.debug('reflector finished: %s', reason)
|
||||
self.factory.finished_deferred.callback(reason)
|
||||
|
||||
# IConsumer stuff
|
||||
|
||||
def registerProducer(self, producer, streaming):
|
||||
self.producer = producer
|
||||
self.streaming = streaming
|
||||
if self.streaming is False:
|
||||
from twisted.internet import reactor
|
||||
reactor.callLater(0, self.producer.resumeProducing)
|
||||
|
||||
def unregisterProducer(self):
|
||||
self.producer = None
|
||||
|
||||
def write(self, data):
|
||||
self.transport.write(data)
|
||||
if self.producer is not None and self.streaming is False:
|
||||
from twisted.internet import reactor
|
||||
reactor.callLater(0, self.producer.resumeProducing)
|
||||
|
||||
def get_blobs_to_send(self, stream_info_manager, stream_hash):
|
||||
log.debug('Getting blobs from stream hash: %s', stream_hash)
|
||||
d = stream_info_manager.get_blobs_for_stream(stream_hash)
|
||||
|
||||
def set_blobs(blob_hashes):
|
||||
for blob_hash, position, iv, length in blob_hashes:
|
||||
log.info("Preparing to send %s", blob_hash)
|
||||
if blob_hash is not None:
|
||||
self.blob_hashes_to_send.append(blob_hash)
|
||||
|
||||
d.addCallback(set_blobs)
|
||||
|
||||
d.addCallback(lambda _: stream_info_manager.get_sd_blob_hashes_for_stream(stream_hash))
|
||||
|
||||
def set_sd_blobs(sd_blob_hashes):
|
||||
for sd_blob_hash in sd_blob_hashes:
|
||||
self.blob_hashes_to_send.append(sd_blob_hash)
|
||||
|
||||
d.addCallback(set_sd_blobs)
|
||||
return d
|
||||
|
||||
def send_handshake(self):
|
||||
log.debug('Sending handshake')
|
||||
self.write(json.dumps({'version': 0}))
|
||||
|
||||
def parse_response(self, buff):
|
||||
try:
|
||||
return json.loads(buff)
|
||||
except ValueError:
|
||||
raise IncompleteResponseError()
|
||||
|
||||
def response_failure_handler(self, err):
|
||||
log.warning("An error occurred handling the response: %s", err.getTraceback())
|
||||
|
||||
def handle_response(self, response_dict):
|
||||
if self.received_handshake_response is False:
|
||||
return self.handle_handshake_response(response_dict)
|
||||
else:
|
||||
return self.handle_normal_response(response_dict)
|
||||
|
||||
def set_not_uploading(self):
|
||||
if self.next_blob_to_send is not None:
|
||||
self.next_blob_to_send.close_read_handle(self.read_handle)
|
||||
self.read_handle = None
|
||||
self.next_blob_to_send = None
|
||||
self.file_sender = None
|
||||
return defer.succeed(None)
|
||||
|
||||
def start_transfer(self):
|
||||
self.write(json.dumps({}))
|
||||
assert self.read_handle is not None, "self.read_handle was None when trying to start the transfer"
|
||||
d = self.file_sender.beginFileTransfer(self.read_handle, self)
|
||||
return d
|
||||
|
||||
def handle_handshake_response(self, response_dict):
|
||||
if 'version' not in response_dict:
|
||||
raise ValueError("Need protocol version number!")
|
||||
self.protocol_version = int(response_dict['version'])
|
||||
if self.protocol_version != 0:
|
||||
raise ValueError("I can't handle protocol version {}!".format(self.protocol_version))
|
||||
self.received_handshake_response = True
|
||||
return defer.succeed(True)
|
||||
|
||||
def handle_normal_response(self, response_dict):
|
||||
if self.file_sender is None: # Expecting Server Info Response
|
||||
if 'send_blob' not in response_dict:
|
||||
raise ValueError("I don't know whether to send the blob or not!")
|
||||
if response_dict['send_blob'] is True:
|
||||
self.file_sender = FileSender()
|
||||
return defer.succeed(True)
|
||||
else:
|
||||
return self.set_not_uploading()
|
||||
else: # Expecting Server Blob Response
|
||||
if 'received_blob' not in response_dict:
|
||||
raise ValueError("I don't know if the blob made it to the intended destination!")
|
||||
else:
|
||||
return self.set_not_uploading()
|
||||
|
||||
def open_blob_for_reading(self, blob):
|
||||
if blob.is_validated():
|
||||
read_handle = blob.open_for_reading()
|
||||
if read_handle is not None:
|
||||
log.debug('Getting ready to send %s', blob.blob_hash)
|
||||
self.next_blob_to_send = blob
|
||||
self.read_handle = read_handle
|
||||
return None
|
||||
raise ValueError("Couldn't open that blob for some reason. blob_hash: {}".format(blob.blob_hash))
|
||||
|
||||
def send_blob_info(self):
|
||||
log.info("Send blob info for %s", self.next_blob_to_send.blob_hash)
|
||||
assert self.next_blob_to_send is not None, "need to have a next blob to send at this point"
|
||||
log.debug('sending blob info')
|
||||
self.write(json.dumps({
|
||||
'blob_hash': self.next_blob_to_send.blob_hash,
|
||||
'blob_size': self.next_blob_to_send.length
|
||||
}))
|
||||
|
||||
def send_next_request(self):
|
||||
if self.file_sender is not None:
|
||||
# send the blob
|
||||
log.debug('Sending the blob')
|
||||
return self.start_transfer()
|
||||
elif self.blob_hashes_to_send:
|
||||
# open the next blob to send
|
||||
blob_hash = self.blob_hashes_to_send[0]
|
||||
log.debug('No current blob, sending the next one: %s', blob_hash)
|
||||
self.blob_hashes_to_send = self.blob_hashes_to_send[1:]
|
||||
d = self.blob_manager.get_blob(blob_hash, True)
|
||||
d.addCallback(self.open_blob_for_reading)
|
||||
# send the server the next blob hash + length
|
||||
d.addCallback(lambda _: self.send_blob_info())
|
||||
return d
|
||||
else:
|
||||
# close connection
|
||||
log.debug('No more blob hashes, closing connection')
|
||||
self.transport.loseConnection()
|
||||
|
||||
|
||||
class LBRYFileReflectorClientFactory(ClientFactory):
|
||||
protocol = LBRYFileReflectorClient
|
||||
|
||||
def __init__(self, blob_manager, stream_info_manager, stream_hash):
|
||||
self.blob_manager = blob_manager
|
||||
self.stream_info_manager = stream_info_manager
|
||||
self.stream_hash = stream_hash
|
||||
self.p = None
|
||||
self.finished_deferred = defer.Deferred()
|
||||
|
||||
def buildProtocol(self, addr):
|
||||
p = self.protocol()
|
||||
p.factory = self
|
||||
self.p = p
|
||||
return p
|
||||
|
||||
def startFactory(self):
|
||||
log.debug('Starting reflector factory')
|
||||
ClientFactory.startFactory(self)
|
||||
|
||||
def startedConnecting(self, connector):
|
||||
log.debug('Started connecting')
|
||||
|
||||
def clientConnectionLost(self, connector, reason):
|
||||
"""If we get disconnected, reconnect to server."""
|
||||
log.debug("connection lost: %s", reason)
|
||||
|
||||
def clientConnectionFailed(self, connector, reason):
|
||||
log.debug("connection failed: %s", reason)
|
||||
|
||||
|
||||
class LBRYBlobReflectorClient(Protocol):
|
||||
# Protocol stuff
|
||||
|
||||
def connectionMade(self):
|
||||
self.blob_manager = self.factory.blob_manager
|
||||
self.response_buff = ''
|
||||
self.outgoing_buff = ''
|
||||
self.blob_hashes_to_send = self.factory.blobs
|
||||
self.next_blob_to_send = None
|
||||
self.blob_read_handle = None
|
||||
self.received_handshake_response = False
|
||||
self.protocol_version = None
|
||||
self.file_sender = None
|
||||
self.producer = None
|
||||
self.streaming = False
|
||||
d = self.send_handshake()
|
||||
d.addErrback(lambda err: log.warning("An error occurred immediately: %s", err.getTraceback()))
|
||||
|
||||
def dataReceived(self, data):
|
||||
log.debug('Recieved %s', data)
|
||||
self.response_buff += data
|
||||
try:
|
||||
msg = self.parse_response(self.response_buff)
|
||||
except IncompleteResponseError:
|
||||
pass
|
||||
else:
|
||||
self.response_buff = ''
|
||||
d = self.handle_response(msg)
|
||||
d.addCallback(lambda _: self.send_next_request())
|
||||
d.addErrback(self.response_failure_handler)
|
||||
|
||||
def connectionLost(self, reason):
|
||||
if reason.check(error.ConnectionDone):
|
||||
log.debug('Finished sending data via reflector')
|
||||
self.factory.finished_deferred.callback(True)
|
||||
else:
|
||||
log.debug('reflector finished: %s', reason)
|
||||
self.factory.finished_deferred.callback(reason)
|
||||
|
||||
# IConsumer stuff
|
||||
|
||||
def registerProducer(self, producer, streaming):
|
||||
self.producer = producer
|
||||
self.streaming = streaming
|
||||
if self.streaming is False:
|
||||
from twisted.internet import reactor
|
||||
reactor.callLater(0, self.producer.resumeProducing)
|
||||
|
||||
def unregisterProducer(self):
|
||||
self.producer = None
|
||||
|
||||
def write(self, data):
|
||||
self.transport.write(data)
|
||||
if self.producer is not None and self.streaming is False:
|
||||
from twisted.internet import reactor
|
||||
reactor.callLater(0, self.producer.resumeProducing)
|
||||
|
||||
def send_handshake(self):
|
||||
log.debug('Sending handshake')
|
||||
self.write(json.dumps({'version': 0}))
|
||||
return defer.succeed(None)
|
||||
|
||||
def parse_response(self, buff):
|
||||
try:
|
||||
return json.loads(buff)
|
||||
except ValueError:
|
||||
raise IncompleteResponseError()
|
||||
|
||||
def response_failure_handler(self, err):
|
||||
log.warning("An error occurred handling the response: %s", err.getTraceback())
|
||||
|
||||
def handle_response(self, response_dict):
|
||||
if self.received_handshake_response is False:
|
||||
return self.handle_handshake_response(response_dict)
|
||||
else:
|
||||
return self.handle_normal_response(response_dict)
|
||||
|
||||
def set_not_uploading(self):
|
||||
if self.next_blob_to_send is not None:
|
||||
self.next_blob_to_send.close_read_handle(self.read_handle)
|
||||
self.read_handle = None
|
||||
self.next_blob_to_send = None
|
||||
self.file_sender = None
|
||||
return defer.succeed(None)
|
||||
|
||||
def start_transfer(self):
|
||||
self.write(json.dumps({}))
|
||||
assert self.read_handle is not None, "self.read_handle was None when trying to start the transfer"
|
||||
d = self.file_sender.beginFileTransfer(self.read_handle, self)
|
||||
return d
|
||||
|
||||
def handle_handshake_response(self, response_dict):
|
||||
if 'version' not in response_dict:
|
||||
raise ValueError("Need protocol version number!")
|
||||
self.protocol_version = int(response_dict['version'])
|
||||
if self.protocol_version != 0:
|
||||
raise ValueError("I can't handle protocol version {}!".format(self.protocol_version))
|
||||
self.received_handshake_response = True
|
||||
return defer.succeed(True)
|
||||
|
||||
def handle_normal_response(self, response_dict):
|
||||
if self.file_sender is None: # Expecting Server Info Response
|
||||
if 'send_blob' not in response_dict:
|
||||
raise ValueError("I don't know whether to send the blob or not!")
|
||||
if response_dict['send_blob'] is True:
|
||||
self.file_sender = FileSender()
|
||||
return defer.succeed(True)
|
||||
else:
|
||||
return self.set_not_uploading()
|
||||
else: # Expecting Server Blob Response
|
||||
if 'received_blob' not in response_dict:
|
||||
raise ValueError("I don't know if the blob made it to the intended destination!")
|
||||
else:
|
||||
return self.set_not_uploading()
|
||||
|
||||
def open_blob_for_reading(self, blob):
|
||||
if blob.is_validated():
|
||||
read_handle = blob.open_for_reading()
|
||||
if read_handle is not None:
|
||||
log.debug('Getting ready to send %s', blob.blob_hash)
|
||||
self.next_blob_to_send = blob
|
||||
self.read_handle = read_handle
|
||||
return None
|
||||
raise ValueError("Couldn't open that blob for some reason. blob_hash: {}".format(blob.blob_hash))
|
||||
|
||||
def send_blob_info(self):
|
||||
log.info("Send blob info for %s", self.next_blob_to_send.blob_hash)
|
||||
assert self.next_blob_to_send is not None, "need to have a next blob to send at this point"
|
||||
log.debug('sending blob info')
|
||||
self.write(json.dumps({
|
||||
'blob_hash': self.next_blob_to_send.blob_hash,
|
||||
'blob_size': self.next_blob_to_send.length
|
||||
}))
|
||||
|
||||
def send_next_request(self):
|
||||
if self.file_sender is not None:
|
||||
# send the blob
|
||||
log.debug('Sending the blob')
|
||||
return self.start_transfer()
|
||||
elif self.blob_hashes_to_send:
|
||||
# open the next blob to send
|
||||
blob_hash = self.blob_hashes_to_send[0]
|
||||
log.debug('No current blob, sending the next one: %s', blob_hash)
|
||||
self.blob_hashes_to_send = self.blob_hashes_to_send[1:]
|
||||
d = self.blob_manager.get_blob(blob_hash, True)
|
||||
d.addCallback(self.open_blob_for_reading)
|
||||
# send the server the next blob hash + length
|
||||
d.addCallback(lambda _: self.send_blob_info())
|
||||
return d
|
||||
else:
|
||||
# close connection
|
||||
log.debug('No more blob hashes, closing connection')
|
||||
self.transport.loseConnection()
|
||||
|
||||
|
||||
class LBRYBlobReflectorClientFactory(ClientFactory):
|
||||
protocol = LBRYBlobReflectorClient
|
||||
|
||||
def __init__(self, blob_manager, blobs):
|
||||
self.blob_manager = blob_manager
|
||||
self.blobs = blobs
|
||||
self.p = None
|
||||
self.finished_deferred = defer.Deferred()
|
||||
|
||||
def buildProtocol(self, addr):
|
||||
p = self.protocol()
|
||||
p.factory = self
|
||||
self.p = p
|
||||
return p
|
||||
|
||||
def startFactory(self):
|
||||
log.debug('Starting reflector factory')
|
||||
ClientFactory.startFactory(self)
|
||||
|
||||
def startedConnecting(self, connector):
|
||||
log.debug('Started connecting')
|
||||
|
||||
def clientConnectionLost(self, connector, reason):
|
||||
"""If we get disconnected, reconnect to server."""
|
||||
log.debug("connection lost: %s", reason)
|
||||
|
||||
def clientConnectionFailed(self, connector, reason):
|
||||
log.debug("connection failed: %s", reason)
|
||||
@@ -0,0 +1,147 @@
|
||||
import logging
|
||||
from twisted.python import failure
|
||||
from twisted.internet import error, defer
|
||||
from twisted.internet.protocol import Protocol, ServerFactory
|
||||
import json
|
||||
from lbrynet.core.utils import is_valid_blobhash
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class ReflectorServer(Protocol):
|
||||
|
||||
def connectionMade(self):
|
||||
peer_info = self.transport.getPeer()
|
||||
log.debug('Connection made to %s', peer_info)
|
||||
self.peer = self.factory.peer_manager.get_peer(peer_info.host, peer_info.port)
|
||||
self.blob_manager = self.factory.blob_manager
|
||||
self.received_handshake = False
|
||||
self.peer_version = None
|
||||
self.receiving_blob = False
|
||||
self.incoming_blob = None
|
||||
self.blob_write = None
|
||||
self.blob_finished_d = None
|
||||
self.cancel_write = None
|
||||
self.request_buff = ""
|
||||
|
||||
def connectionLost(self, reason=failure.Failure(error.ConnectionDone())):
|
||||
log.info("Reflector upload from %s finished" % self.peer.host)
|
||||
|
||||
def dataReceived(self, data):
|
||||
if self.receiving_blob:
|
||||
# log.debug('Writing data to blob')
|
||||
self.blob_write(data)
|
||||
else:
|
||||
log.debug('Not yet recieving blob, data needs further processing')
|
||||
self.request_buff += data
|
||||
msg, extra_data = self._get_valid_response(self.request_buff)
|
||||
if msg is not None:
|
||||
self.request_buff = ''
|
||||
d = self.handle_request(msg)
|
||||
d.addCallbacks(self.send_response, self.handle_error)
|
||||
if self.receiving_blob and extra_data:
|
||||
log.debug('Writing extra data to blob')
|
||||
self.blob_write(extra_data)
|
||||
|
||||
def _get_valid_response(self, response_msg):
|
||||
extra_data = None
|
||||
response = None
|
||||
curr_pos = 0
|
||||
while True:
|
||||
next_close_paren = response_msg.find('}', curr_pos)
|
||||
if next_close_paren != -1:
|
||||
curr_pos = next_close_paren + 1
|
||||
try:
|
||||
response = json.loads(response_msg[:curr_pos])
|
||||
except ValueError:
|
||||
if curr_pos > 100:
|
||||
raise Exception("error decoding response")
|
||||
else:
|
||||
pass
|
||||
else:
|
||||
extra_data = response_msg[curr_pos:]
|
||||
break
|
||||
else:
|
||||
break
|
||||
return response, extra_data
|
||||
|
||||
def handle_request(self, request_dict):
|
||||
if self.received_handshake is False:
|
||||
return self.handle_handshake(request_dict)
|
||||
else:
|
||||
return self.handle_normal_request(request_dict)
|
||||
|
||||
def handle_handshake(self, request_dict):
|
||||
log.debug('Handling handshake')
|
||||
if 'version' not in request_dict:
|
||||
raise ValueError("Client should send version")
|
||||
self.peer_version = int(request_dict['version'])
|
||||
if self.peer_version != 0:
|
||||
raise ValueError("I don't know that version!")
|
||||
self.received_handshake = True
|
||||
return defer.succeed({'version': 0})
|
||||
|
||||
def determine_blob_needed(self, blob):
|
||||
if blob.is_validated():
|
||||
return {'send_blob': False}
|
||||
else:
|
||||
self.incoming_blob = blob
|
||||
self.blob_finished_d, self.blob_write, self.cancel_write = blob.open_for_writing(self.peer)
|
||||
self.blob_finished_d.addCallback(lambda _ :self.blob_manager.blob_completed(blob))
|
||||
return {'send_blob': True}
|
||||
|
||||
def close_blob(self):
|
||||
self.blob_finished_d = None
|
||||
self.blob_write = None
|
||||
self.cancel_write = None
|
||||
self.incoming_blob = None
|
||||
self.receiving_blob = False
|
||||
|
||||
def handle_normal_request(self, request_dict):
|
||||
if self.blob_write is None:
|
||||
# we haven't opened a blob yet, meaning we must be waiting for the
|
||||
# next message containing a blob hash and a length. this message
|
||||
# should be it. if it's one we want, open the blob for writing, and
|
||||
# return a nice response dict (in a Deferred) saying go ahead
|
||||
if not 'blob_hash' in request_dict or not 'blob_size' in request_dict:
|
||||
raise ValueError("Expected a blob hash and a blob size")
|
||||
if not is_valid_blobhash(request_dict['blob_hash']):
|
||||
raise ValueError("Got a bad blob hash: {}".format(request_dict['blob_hash']))
|
||||
log.debug('Recieved info for blob: %s', request_dict['blob_hash'])
|
||||
d = self.blob_manager.get_blob(
|
||||
request_dict['blob_hash'],
|
||||
True,
|
||||
int(request_dict['blob_size'])
|
||||
)
|
||||
d.addCallback(self.determine_blob_needed)
|
||||
else:
|
||||
# we have a blob open already, so this message should have nothing
|
||||
# important in it. to the deferred that fires when the blob is done,
|
||||
# add a callback which returns a nice response dict saying to keep
|
||||
# sending, and then return that deferred
|
||||
log.debug('blob is already open')
|
||||
self.receiving_blob = True
|
||||
d = self.blob_finished_d
|
||||
d.addCallback(lambda _: self.close_blob())
|
||||
d.addCallback(lambda _: {'received_blob': True})
|
||||
return d
|
||||
|
||||
def send_response(self, response_dict):
|
||||
self.transport.write(json.dumps(response_dict))
|
||||
|
||||
def handle_error(self, err):
|
||||
log.error(err.getTraceback())
|
||||
self.transport.loseConnection()
|
||||
|
||||
|
||||
class ReflectorServerFactory(ServerFactory):
|
||||
protocol = ReflectorServer
|
||||
|
||||
def __init__(self, peer_manager, blob_manager):
|
||||
self.peer_manager = peer_manager
|
||||
self.blob_manager = blob_manager
|
||||
|
||||
def buildProtocol(self, addr):
|
||||
log.debug('Creating a protocol for %s', addr)
|
||||
return ServerFactory.buildProtocol(self, addr)
|
||||
@@ -0,0 +1,75 @@
|
||||
#!/bin/sh
|
||||
|
||||
if [ "$EUID" -ne 0 ]
|
||||
then echo "Please run as sudo"
|
||||
exit
|
||||
fi
|
||||
|
||||
echo "**********************************"
|
||||
echo "Installing LBRY and dependencies"
|
||||
echo "**********************************"
|
||||
|
||||
if ! xcode-select -p &>/dev/null; then
|
||||
echo
|
||||
echo "You need to install xcode command line tools to install lbry."
|
||||
echo "A popup to do so should appear, once you're done the installer will resume"
|
||||
echo
|
||||
xcode-select --install &>/dev/null
|
||||
while ! xcode-select -p &>/dev/null; do
|
||||
sleep 1
|
||||
done
|
||||
echo "Installed xcode command line tools"
|
||||
else
|
||||
echo "Xcode command line tools already installed..."
|
||||
fi
|
||||
|
||||
if ! which brew &>/dev/null; then
|
||||
echo "Installing brew..."
|
||||
sudo -u ${SUDO_USER} ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" < /dev/null &>/dev/null
|
||||
else
|
||||
echo "Updating brew..."
|
||||
sudo -u ${SUDO_USER} brew update &>/dev/null
|
||||
fi
|
||||
|
||||
if ! brew list mpfr &>/dev/null; then
|
||||
echo "Installing mpfr..."
|
||||
sudo -u ${SUDO_USER} brew install mpfr &>/dev/null
|
||||
else
|
||||
echo "mpfr already installed..."
|
||||
fi
|
||||
|
||||
if ! brew list libmpc &>/dev/null; then
|
||||
echo "Installing libmpc..."
|
||||
sudo -u ${SUDO_USER} brew install libmpc &>/dev/null
|
||||
else
|
||||
echo "libmpc already installed..."
|
||||
fi
|
||||
|
||||
if ! which pip &>/dev/null; then
|
||||
echo "Installing pip..."
|
||||
sudo easy_install pip &>/dev/null
|
||||
else
|
||||
echo "pip already installed"
|
||||
fi
|
||||
|
||||
echo "Cloning and installing lbryum..."
|
||||
git clone --depth 1 https://github.com/lbryio/lbryum.git &>/dev/null
|
||||
cd lbryum
|
||||
sudo python setup.py install &>/dev/null
|
||||
cd ..
|
||||
rm -rf lbryum &>/dev/null
|
||||
|
||||
echo "Cloning and installing lbry..."
|
||||
git clone --depth 1 https://github.com/lbryio/lbry.git &>/dev/null
|
||||
cd lbry
|
||||
sudo python setup.py install &>/dev/null
|
||||
cd ..
|
||||
rm -rf lbry &>/dev/null
|
||||
|
||||
sudo chmod -R 755 /Library/Python/2.7/site-packages/
|
||||
|
||||
echo "**********************************"
|
||||
echo "All done!"
|
||||
echo "**********************************"
|
||||
echo " "
|
||||
echo "run 'lbrynet-daemon' to start lbry"
|
||||
@@ -10,3 +10,11 @@
|
||||
*.iml
|
||||
|
||||
id.conf
|
||||
|
||||
lbrycrd-cli
|
||||
lbrycrd-osx.zip
|
||||
lbrycrd-tx
|
||||
lbrycrdd
|
||||
|
||||
lbrynet.*.dmg
|
||||
LBRY.app
|
||||
|
After Width: | Height: | Size: 8.5 KiB |
@@ -0,0 +1,11 @@
|
||||
badge_icon = 'app.icns'
|
||||
icon_locations = {
|
||||
'LBRY.app': (115, 164),
|
||||
'Applications': (387, 164)
|
||||
}
|
||||
background='dmg_background.png'
|
||||
default_view='icon-view'
|
||||
symlinks = { 'Applications': '/Applications' }
|
||||
window_rect=((200, 200), (500, 320))
|
||||
files = [ 'LBRY.app' ]
|
||||
icon_size=128
|
||||
@@ -27,7 +27,7 @@ if not os.path.isfile(lbrycrdd_path_conf):
|
||||
f.write(lbrycrdd_path)
|
||||
f.close()
|
||||
|
||||
from lbrynet.lbrynet_daemon.LBRYDaemonServer import LBRYDaemonServer
|
||||
from lbrynet.lbrynet_daemon.LBRYDaemonServer import LBRYDaemonServer, LBRYDaemonRequest
|
||||
from lbrynet.conf import API_PORT, API_INTERFACE, ICON_PATH, APP_NAME
|
||||
from lbrynet.conf import UI_ADDRESS
|
||||
|
||||
@@ -74,16 +74,13 @@ class LBRYDaemonApp(AppKit.NSApplication):
|
||||
LBRYNotify("LBRY needs an internet connection to start, try again when one is available")
|
||||
sys.exit(0)
|
||||
|
||||
# if not subprocess.check_output("git ls-remote https://github.com/lbryio/lbry-web-ui.git | grep HEAD | cut -f 1",
|
||||
# shell=True):
|
||||
# LBRYNotify(
|
||||
# "You should have been prompted to install xcode command line tools, please do so and then start LBRY")
|
||||
# sys.exit(0)
|
||||
|
||||
lbry = LBRYDaemonServer()
|
||||
d = lbry.start()
|
||||
d.addCallback(lambda _: webbrowser.open(UI_ADDRESS))
|
||||
reactor.listenTCP(API_PORT, server.Site(lbry.root), interface=API_INTERFACE)
|
||||
lbrynet_server = server.Site(lbry.root)
|
||||
lbrynet_server.requestFactory = LBRYDaemonRequest
|
||||
reactor.listenTCP(API_PORT, lbrynet_server, interface=API_INTERFACE)
|
||||
|
||||
def openui_(self, sender):
|
||||
webbrowser.open(UI_ADDRESS)
|
||||
|
||||
@@ -9,17 +9,11 @@ ON_TRAVIS=false
|
||||
|
||||
rm -rf build dist LBRY.app
|
||||
|
||||
pip install wheel
|
||||
# the default py2app (v0.9) has a bug that is fixed in the head of /metachris/py2app
|
||||
pip install git+https://github.com/metachris/py2app
|
||||
pip install jsonrpc
|
||||
|
||||
mkdir -p $tmp
|
||||
cd $tmp
|
||||
|
||||
echo "Updating lbrynet"
|
||||
if [ -z ${TRAVIS_BUILD_DIR+x} ]; then
|
||||
# building locally
|
||||
mkdir -p $tmp
|
||||
cd $tmp
|
||||
git clone --depth 1 http://github.com/lbryio/lbry.git
|
||||
cd lbry
|
||||
LBRY="${tmp}/lbry"
|
||||
@@ -29,6 +23,39 @@ else
|
||||
cd ${TRAVIS_BUILD_DIR}
|
||||
LBRY=${TRAVIS_BUILD_DIR}
|
||||
fi
|
||||
|
||||
pip install wheel
|
||||
MODULES="pyobjc-core pyobjc-framework-Cocoa pyobjc-framework-CFNetwork pyobjc-framework-Quartz"
|
||||
if [ ${ON_TRAVIS} = true ]; then
|
||||
WHEEL_DIR="${TRAVIS_BUILD_DIR}/cache/wheel"
|
||||
mkdir -p "${WHEEL_DIR}"
|
||||
# mapping from the package name to the
|
||||
# actual built wheel file is surprisingly
|
||||
# hard so instead of checking for the existance
|
||||
# of each wheel, we mark with a file when they've all been
|
||||
# built and skip when that file exists
|
||||
for MODULE in ${MODULES}; do
|
||||
if [ ! -f "${WHEEL_DIR}"/${MODULE}.finished ]; then
|
||||
pip wheel -w "${WHEEL_DIR}" ${MODULE}
|
||||
touch "${WHEEL_DIR}"/${MODULE}.finished
|
||||
fi
|
||||
done
|
||||
pip install "${WHEEL_DIR}"/*.whl
|
||||
else
|
||||
pip install $MODULES
|
||||
fi
|
||||
|
||||
pip install dmgbuild
|
||||
pip show dmgbuild
|
||||
|
||||
export PATH=${PATH}:/Library/Frameworks/Python.framework/Versions/2.7/bin
|
||||
dmgbuild --help
|
||||
|
||||
pip install jsonrpc certifi
|
||||
|
||||
# the default py2app (v0.9) has a bug that is fixed in the head of /metachris/py2app
|
||||
pip install git+https://github.com/metachris/py2app
|
||||
|
||||
NAME=`python setup.py --name`
|
||||
VERSION=`python setup.py -V`
|
||||
pip install -r requirements.txt
|
||||
@@ -48,29 +75,12 @@ codesign -s "${LBRY_DEVELOPER_ID}" -f "${DEST}/dist/LBRYURIHandler.app/Contents/
|
||||
codesign --deep -s "${LBRY_DEVELOPER_ID}" -f "${DEST}/dist/LBRYURIHandler.app/Contents/MacOS/LBRYURIHandler"
|
||||
codesign -vvvv "${DEST}/dist/LBRYURIHandler.app"
|
||||
|
||||
pip install certifi
|
||||
MODULES="pyobjc-core pyobjc-framework-Cocoa pyobjc-framework-CFNetwork"
|
||||
if [ ${ON_TRAVIS} = true ]; then
|
||||
WHEEL_DIR="${TRAVIS_BUILD_DIR}/cache/wheel"
|
||||
mkdir -p "${WHEEL_DIR}"
|
||||
# mapping from the package name to the
|
||||
# actual built wheel file is surprisingly
|
||||
# hard so instead of checking for the existance
|
||||
# of each wheel, we mark with a file when they've all been
|
||||
# built and skip when that file exists
|
||||
if [ ! -f "${WHEEL_DIR}"/finished ]; then
|
||||
pip wheel -w "${WHEEL_DIR}" ${MODULES}
|
||||
touch "${WHEEL_DIR}"/finished
|
||||
fi
|
||||
pip install "${WHEEL_DIR}"/*.whl
|
||||
else
|
||||
pip install $MODULES
|
||||
fi
|
||||
|
||||
|
||||
# add lbrycrdd as a resource. Following
|
||||
# http://stackoverflow.com/questions/11370012/can-executables-made-with-py2app-include-other-terminal-scripts-and-run-them
|
||||
wget https://github.com/lbryio/lbrycrd/releases/download/v0.3-osx/lbrycrdd
|
||||
# LBRYCRDD_URL="$(curl https://api.github.com/repos/lbryio/lbrycrd/releases/latest | grep 'browser_download_url' | grep osx | cut -d'"' -f4)"
|
||||
LBRYCRDD_URL="https://github.com/lbryio/lbrycrd/releases/download/v0.3.15/lbrycrd-osx.zip"
|
||||
wget "${LBRYCRDD_URL}" --output-document lbrycrd-osx.zip
|
||||
unzip -o lbrycrd-osx.zip
|
||||
python setup_app.py py2app --resources lbrycrdd
|
||||
|
||||
chmod +x "${DEST}/dist/LBRY.app/Contents/Resources/lbrycrdd"
|
||||
@@ -102,5 +112,4 @@ codesign -vvvv "${DEST}/dist/LBRY.app"
|
||||
rm -rf $tmp
|
||||
mv dist/LBRY.app LBRY.app
|
||||
rm -rf dist "${NAME}.${VERSION}.dmg"
|
||||
# TODO: make this pretty!
|
||||
hdiutil create "${NAME}.${VERSION}.dmg" -volname lbry -srcfolder LBRY.app
|
||||
dmgbuild -s dmg_settings.py "LBRY" "${NAME}.${VERSION}.dmg"
|
||||
@@ -42,5 +42,7 @@ pip install mock pylint
|
||||
trial tests
|
||||
# TODO: submit coverage report to coveralls
|
||||
|
||||
# Ignoring distutils because: https://github.com/PyCQA/pylint/issues/73
|
||||
# TODO: as code quality improves, make pylint be more strict
|
||||
pylint -E --disable=inherit-non-class --disable=no-member lbrynet
|
||||
pylint -E --disable=inherit-non-class --disable=no-member --ignored-modules=distutils \
|
||||
--enable=unused-import lbrynet
|
||||
@@ -42,7 +42,7 @@ DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
|
||||
|
||||
if [ -z "$(pgrep lbrynet-daemon)" ]; then
|
||||
echo "running lbrynet-daemon..."
|
||||
$DIR/lbrynet-daemon --branch="$WEB_UI_BRANCH" &
|
||||
$DIR/lbrynet-daemon --no-launch --branch="$WEB_UI_BRANCH" &
|
||||
sleep 3 # let the daemon load before connecting
|
||||
fi
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
[Desktop Entry]
|
||||
Version=0.3.8
|
||||
Version=0.4.2
|
||||
Name=LBRY
|
||||
Comment=The world's first user-owned content marketplace
|
||||
Icon=lbry
|
||||
|
||||
@@ -170,7 +170,7 @@ addfile "$PACKAGING_DIR/lbry-temp-symlink" usr/bin/lbry
|
||||
|
||||
# add lbrycrdd and lbrycrd-cli
|
||||
mkdir -p "$PACKAGING_DIR/bins"
|
||||
wget http://s3.amazonaws.com/files.lbry.io/bins.zip --output-document "$PACKAGING_DIR/bins.zip"
|
||||
wget "$(curl https://api.github.com/repos/lbryio/lbrycrd/releases/latest | grep 'browser_download_url' | grep linux | cut -d'"' -f4)" --output-document "$PACKAGING_DIR/bins.zip"
|
||||
unzip "$PACKAGING_DIR/bins.zip" -d "$PACKAGING_DIR/bins/"
|
||||
addfile "$PACKAGING_DIR/bins/lbrycrdd" usr/bin/lbrycrdd
|
||||
addfile "$PACKAGING_DIR/bins/lbrycrd-cli" usr/bin/lbrycrd-cli
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
import os
|
||||
import webbrowser
|
||||
import subprocess
|
||||
import sys
|
||||
from time import sleep
|
||||
|
||||
from jsonrpc.proxy import JSONRPCProxy
|
||||
|
||||
from lbrynet.conf import UI_ADDRESS, API_CONNECTION_STRING
|
||||
|
||||
|
||||
class LBRYURIHandler(object):
|
||||
def __init__(self):
|
||||
self.started_daemon = False
|
||||
self.daemon = JSONRPCProxy.from_url(API_CONNECTION_STRING)
|
||||
|
||||
def handle_osx(self, lbry_name):
|
||||
self.check_daemon()
|
||||
if not self.started_daemon:
|
||||
os.system("open /Applications/LBRY.app")
|
||||
sleep(3)
|
||||
|
||||
lbry_name = self.parse_name(lbry_name)
|
||||
self.open_address(lbry_name)
|
||||
|
||||
def handle_linux(self, lbry_name):
|
||||
self.check_daemon()
|
||||
if not self.started_daemon:
|
||||
cmd = r'DIR = "$( cd "$(dirname "${BASH_SOURCE[0]}" )" && pwd )"' \
|
||||
r'if [-z "$(pgrep lbrynet-daemon)"]; then' \
|
||||
r'echo "running lbrynet-daemon..."' \
|
||||
r'$DIR / lbrynet - daemon &' \
|
||||
r'sleep 3 # let the daemon load before connecting' \
|
||||
r'fi'
|
||||
subprocess.Popen(cmd, shell=True)
|
||||
|
||||
lbry_name = self.parse_name(lbry_name)
|
||||
self.open_address(lbry_name)
|
||||
|
||||
def handle_win32(self, lbry_name):
|
||||
# Opening LBRY.exe with lbry_name as arg prevents the need to
|
||||
# make a separate call to open_address()
|
||||
self.check_daemon()
|
||||
lbry_name = self.parse_name(lbry_name)
|
||||
if self.started_daemon:
|
||||
self.open_address(lbry_name)
|
||||
else:
|
||||
lbry_path = os.path.join(os.environ["PROGRAMFILES"], "LBRY", "LBRY.exe ")
|
||||
subprocess.call(lbry_path + lbry_name)
|
||||
|
||||
def check_daemon(self):
|
||||
try:
|
||||
self.started_daemon = self.daemon.is_running()
|
||||
except:
|
||||
self.started_daemon = False
|
||||
|
||||
@staticmethod
|
||||
def parse_name(lbry_name):
|
||||
if lbry_name[:7].lower() == "lbry://":
|
||||
if lbry_name[-1] == "/":
|
||||
return lbry_name[7:-1]
|
||||
else:
|
||||
return lbry_name[7:]
|
||||
else:
|
||||
if lbry_name[-1] == "/":
|
||||
return lbry_name[:-1]
|
||||
else:
|
||||
return lbry_name[:]
|
||||
|
||||
@staticmethod
|
||||
def open_address(lbry_name):
|
||||
if lbry_name == "lbry" or lbry_name == "" or lbry_name is None:
|
||||
webbrowser.open(UI_ADDRESS)
|
||||
else:
|
||||
webbrowser.open(UI_ADDRESS + "/?show=" + lbry_name)
|
||||
|
||||
|
||||
def main(args):
|
||||
if len(args) != 1:
|
||||
args = ["lbry://lbry"]
|
||||
name = args[0][7:]
|
||||
if sys.platform == "darwin":
|
||||
LBRYURIHandler().handle_osx(lbry_name=name)
|
||||
elif os.name == "nt":
|
||||
LBRYURIHandler().handle_win32(lbry_name=name)
|
||||
else:
|
||||
LBRYURIHandler().handle_linux(lbry_name=name)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(sys.argv[1:])
|
||||
@@ -0,0 +1,15 @@
|
||||
Windows Registry Editor Version 5.00
|
||||
|
||||
[HKEY_CLASSES_ROOT\lbry]
|
||||
@="URL:LBRY Protocol"
|
||||
"URL Protocol"=""
|
||||
|
||||
[HKEY_CLASSES_ROOT\lbry\DefaultIcon]
|
||||
@="LBRY.exe,1"
|
||||
|
||||
[HKEY_CLASSES_ROOT\lbry\shell]
|
||||
|
||||
[HKEY_CLASSES_ROOT\lbry\shell\open]
|
||||
|
||||
[HKEY_CLASSES_ROOT\lbry\shell\open\command]
|
||||
@="\"C:\\Program Files (x86)\\LBRY\\LBRY.exe\" \"%1\""
|
||||
@@ -0,0 +1,304 @@
|
||||
import logging
|
||||
import os
|
||||
import socket
|
||||
import sys
|
||||
import threading
|
||||
import webbrowser
|
||||
|
||||
import win32api
|
||||
import win32con
|
||||
import win32gui_struct
|
||||
from jsonrpc.proxy import JSONRPCProxy
|
||||
from twisted.internet import reactor, error
|
||||
from twisted.web import server
|
||||
|
||||
try:
|
||||
import winxpgui as win32gui
|
||||
except ImportError:
|
||||
import win32gui
|
||||
|
||||
from lbrynet.lbrynet_daemon.LBRYDaemonServer import LBRYDaemonServer, LBRYDaemonRequest
|
||||
from lbrynet.conf import API_PORT, API_INTERFACE, ICON_PATH, APP_NAME
|
||||
from lbrynet.conf import UI_ADDRESS, API_CONNECTION_STRING
|
||||
from packaging.uri_handler.LBRYURIHandler import LBRYURIHandler
|
||||
|
||||
|
||||
if getattr(sys, 'frozen', False) and os.name == "nt":
|
||||
os.environ["REQUESTS_CA_BUNDLE"] = os.path.join(os.path.dirname(sys.executable), "cacert.pem")
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
REMOTE_SERVER = "www.google.com"
|
||||
|
||||
|
||||
def test_internet_connection():
|
||||
try:
|
||||
host = socket.gethostbyname(REMOTE_SERVER)
|
||||
s = socket.create_connection((host, 80), 2)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
|
||||
|
||||
def non_string_iterable(obj):
|
||||
try:
|
||||
iter(obj)
|
||||
except TypeError:
|
||||
return False
|
||||
else:
|
||||
return not isinstance(obj, basestring)
|
||||
|
||||
|
||||
class SysTrayIcon(object):
|
||||
"""TODO"""
|
||||
QUIT = 'QUIT'
|
||||
SPECIAL_ACTIONS = [QUIT]
|
||||
|
||||
FIRST_ID = 1023
|
||||
|
||||
def __init__(self,
|
||||
icon,
|
||||
hover_text,
|
||||
menu_options,
|
||||
on_quit=None,
|
||||
default_menu_index=None,
|
||||
window_class_name=None, ):
|
||||
|
||||
self.icon = icon
|
||||
self.hover_text = hover_text
|
||||
self.on_quit = on_quit
|
||||
|
||||
menu_options = menu_options + (('Quit', None, self.QUIT),)
|
||||
self._next_action_id = self.FIRST_ID
|
||||
self.menu_actions_by_id = set()
|
||||
self.menu_options = self._add_ids_to_menu_options(list(menu_options))
|
||||
self.menu_actions_by_id = dict(self.menu_actions_by_id)
|
||||
del self._next_action_id
|
||||
|
||||
self.default_menu_index = (default_menu_index or 0)
|
||||
self.window_class_name = window_class_name or "SysTrayIconPy"
|
||||
|
||||
message_map = {win32gui.RegisterWindowMessage("TaskbarCreated"): self.restart,
|
||||
win32con.WM_DESTROY: self.destroy,
|
||||
win32con.WM_COMMAND: self.command,
|
||||
win32con.WM_USER + 20: self.notify,}
|
||||
# Register the Window class.
|
||||
window_class = win32gui.WNDCLASS()
|
||||
hinst = window_class.hInstance = win32gui.GetModuleHandle(None)
|
||||
window_class.lpszClassName = self.window_class_name
|
||||
window_class.style = win32con.CS_VREDRAW | win32con.CS_HREDRAW;
|
||||
window_class.hCursor = win32gui.LoadCursor(0, win32con.IDC_ARROW)
|
||||
window_class.hbrBackground = win32con.COLOR_WINDOW
|
||||
window_class.lpfnWndProc = message_map # could also specify a wndproc.
|
||||
classAtom = win32gui.RegisterClass(window_class)
|
||||
# Create the Window.
|
||||
style = win32con.WS_OVERLAPPED | win32con.WS_SYSMENU
|
||||
self.hwnd = win32gui.CreateWindow(classAtom,
|
||||
self.window_class_name,
|
||||
style,
|
||||
0,
|
||||
0,
|
||||
win32con.CW_USEDEFAULT,
|
||||
win32con.CW_USEDEFAULT,
|
||||
0,
|
||||
0,
|
||||
hinst,
|
||||
None)
|
||||
win32gui.UpdateWindow(self.hwnd)
|
||||
self.notify_id = None
|
||||
self.refresh_icon()
|
||||
|
||||
win32gui.PumpMessages()
|
||||
|
||||
def _add_ids_to_menu_options(self, menu_options):
|
||||
result = []
|
||||
for menu_option in menu_options:
|
||||
option_text, option_icon, option_action = menu_option
|
||||
if callable(option_action) or option_action in self.SPECIAL_ACTIONS:
|
||||
self.menu_actions_by_id.add((self._next_action_id, option_action))
|
||||
result.append(menu_option + (self._next_action_id,))
|
||||
elif non_string_iterable(option_action):
|
||||
result.append((option_text,
|
||||
option_icon,
|
||||
self._add_ids_to_menu_options(option_action),
|
||||
self._next_action_id))
|
||||
else:
|
||||
print 'Unknown item', option_text, option_icon, option_action
|
||||
self._next_action_id += 1
|
||||
return result
|
||||
|
||||
def refresh_icon(self):
|
||||
# Try and find a custom icon
|
||||
hinst = win32gui.GetModuleHandle(None)
|
||||
if os.path.isfile(self.icon):
|
||||
icon_flags = win32con.LR_LOADFROMFILE | win32con.LR_DEFAULTSIZE
|
||||
hicon = win32gui.LoadImage(hinst,
|
||||
self.icon,
|
||||
win32con.IMAGE_ICON,
|
||||
0,
|
||||
0,
|
||||
icon_flags)
|
||||
else:
|
||||
print "Can't find icon file - using default."
|
||||
hicon = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
|
||||
|
||||
if self.notify_id:
|
||||
message = win32gui.NIM_MODIFY
|
||||
else:
|
||||
message = win32gui.NIM_ADD
|
||||
self.notify_id = (self.hwnd,
|
||||
0,
|
||||
win32gui.NIF_ICON | win32gui.NIF_MESSAGE | win32gui.NIF_TIP,
|
||||
win32con.WM_USER + 20,
|
||||
hicon,
|
||||
self.hover_text)
|
||||
win32gui.Shell_NotifyIcon(message, self.notify_id)
|
||||
|
||||
def restart(self, hwnd, msg, wparam, lparam):
|
||||
self.refresh_icon()
|
||||
|
||||
def destroy(self, hwnd, msg, wparam, lparam):
|
||||
if self.on_quit: self.on_quit(self)
|
||||
nid = (self.hwnd, 0)
|
||||
win32gui.Shell_NotifyIcon(win32gui.NIM_DELETE, nid)
|
||||
win32gui.PostQuitMessage(0) # Terminate the app.
|
||||
|
||||
def notify(self, hwnd, msg, wparam, lparam):
|
||||
if lparam == win32con.WM_LBUTTONDBLCLK:
|
||||
self.execute_menu_option(self.default_menu_index + self.FIRST_ID)
|
||||
elif lparam == win32con.WM_RBUTTONUP:
|
||||
self.show_menu()
|
||||
elif lparam == win32con.WM_LBUTTONUP:
|
||||
pass
|
||||
return True
|
||||
|
||||
def show_menu(self):
|
||||
menu = win32gui.CreatePopupMenu()
|
||||
self.create_menu(menu, self.menu_options)
|
||||
# win32gui.SetMenuDefaultItem(menu, 1000, 0)
|
||||
|
||||
pos = win32gui.GetCursorPos()
|
||||
# See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/menus_0hdi.asp
|
||||
win32gui.SetForegroundWindow(self.hwnd)
|
||||
win32gui.TrackPopupMenu(menu,
|
||||
win32con.TPM_LEFTALIGN,
|
||||
pos[0],
|
||||
pos[1],
|
||||
0,
|
||||
self.hwnd,
|
||||
None)
|
||||
win32gui.PostMessage(self.hwnd, win32con.WM_NULL, 0, 0)
|
||||
|
||||
def create_menu(self, menu, menu_options):
|
||||
for option_text, option_icon, option_action, option_id in menu_options[::-1]:
|
||||
if option_icon:
|
||||
option_icon = self.prep_menu_icon(option_icon)
|
||||
|
||||
if option_id in self.menu_actions_by_id:
|
||||
item, extras = win32gui_struct.PackMENUITEMINFO(text=option_text,
|
||||
hbmpItem=option_icon,
|
||||
wID=option_id)
|
||||
win32gui.InsertMenuItem(menu, 0, 1, item)
|
||||
else:
|
||||
submenu = win32gui.CreatePopupMenu()
|
||||
self.create_menu(submenu, option_action)
|
||||
item, extras = win32gui_struct.PackMENUITEMINFO(text=option_text,
|
||||
hbmpItem=option_icon,
|
||||
hSubMenu=submenu)
|
||||
win32gui.InsertMenuItem(menu, 0, 1, item)
|
||||
|
||||
def prep_menu_icon(self, icon):
|
||||
# First load the icon.
|
||||
ico_x = win32api.GetSystemMetrics(win32con.SM_CXSMICON)
|
||||
ico_y = win32api.GetSystemMetrics(win32con.SM_CYSMICON)
|
||||
hicon = win32gui.LoadImage(0, icon, win32con.IMAGE_ICON, ico_x, ico_y, win32con.LR_LOADFROMFILE)
|
||||
|
||||
hdcBitmap = win32gui.CreateCompatibleDC(0)
|
||||
hdcScreen = win32gui.GetDC(0)
|
||||
hbm = win32gui.CreateCompatibleBitmap(hdcScreen, ico_x, ico_y)
|
||||
hbmOld = win32gui.SelectObject(hdcBitmap, hbm)
|
||||
# Fill the background.
|
||||
brush = win32gui.GetSysColorBrush(win32con.COLOR_MENU)
|
||||
win32gui.FillRect(hdcBitmap, (0, 0, 16, 16), brush)
|
||||
# unclear if brush needs to be feed. Best clue I can find is:
|
||||
# "GetSysColorBrush returns a cached brush instead of allocating a new
|
||||
# one." - implies no DeleteObject
|
||||
# draw the icon
|
||||
win32gui.DrawIconEx(hdcBitmap, 0, 0, hicon, ico_x, ico_y, 0, 0, win32con.DI_NORMAL)
|
||||
win32gui.SelectObject(hdcBitmap, hbmOld)
|
||||
win32gui.DeleteDC(hdcBitmap)
|
||||
|
||||
return hbm
|
||||
|
||||
def command(self, hwnd, msg, wparam, lparam):
|
||||
id = win32gui.LOWORD(wparam)
|
||||
self.execute_menu_option(id)
|
||||
|
||||
def execute_menu_option(self, id):
|
||||
menu_action = self.menu_actions_by_id[id]
|
||||
if menu_action == self.QUIT:
|
||||
self.exit_app()
|
||||
else:
|
||||
menu_action(self)
|
||||
|
||||
def exit_app(self):
|
||||
win32gui.DestroyWindow(self.hwnd)
|
||||
|
||||
|
||||
def main(lbry_name=None):
|
||||
def LBRYApp():
|
||||
return SysTrayIcon(icon, hover_text, menu_options, on_quit=stop)
|
||||
|
||||
def openui_(sender):
|
||||
webbrowser.open(UI_ADDRESS)
|
||||
|
||||
def replyToApplicationShouldTerminate_():
|
||||
try:
|
||||
reactor.stop()
|
||||
except error.ReactorNotRunning:
|
||||
log.debug('Reactor already stopped')
|
||||
|
||||
def stop(sysTrayIcon):
|
||||
replyToApplicationShouldTerminate_()
|
||||
|
||||
if getattr(sys, 'frozen', False) and os.name == "nt":
|
||||
icon = os.path.join(os.path.dirname(sys.executable), ICON_PATH, 'lbry16.ico')
|
||||
else:
|
||||
icon = os.path.join(ICON_PATH, 'lbry16.ico')
|
||||
|
||||
hover_text = APP_NAME
|
||||
menu_options = (('Open', icon, openui_),)
|
||||
|
||||
if not test_internet_connection():
|
||||
log.warn('No Internet Connection')
|
||||
sys.exit(1)
|
||||
|
||||
systray_thread = threading.Thread(target=LBRYApp)
|
||||
systray_thread.daemon = True
|
||||
systray_thread.start()
|
||||
|
||||
lbry = LBRYDaemonServer()
|
||||
d = lbry.start()
|
||||
d.addCallback(lambda _: LBRYURIHandler.open_address(lbry_name))
|
||||
lbrynet_server = server.Site(lbry.root)
|
||||
lbrynet_server.requestFactory = LBRYDaemonRequest
|
||||
reactor.listenTCP(API_PORT, lbrynet_server, interface=API_INTERFACE)
|
||||
reactor.run()
|
||||
|
||||
if __name__ == '__main__':
|
||||
lbry_daemon = JSONRPCProxy.from_url(API_CONNECTION_STRING)
|
||||
|
||||
try:
|
||||
started_daemon = lbry_daemon.is_running()
|
||||
except:
|
||||
started_daemon = False
|
||||
|
||||
try:
|
||||
lbry_name = LBRYURIHandler.parse_name(sys.argv[1])
|
||||
except IndexError:
|
||||
lbry_name = None
|
||||
|
||||
if started_daemon:
|
||||
LBRYURIHandler.open_address(lbry_name)
|
||||
else:
|
||||
main(lbry_name)
|
||||
|
After Width: | Height: | Size: 97 KiB |
|
After Width: | Height: | Size: 1.1 KiB |
|
After Width: | Height: | Size: 361 KiB |
|
After Width: | Height: | Size: 5.3 KiB |
|
After Width: | Height: | Size: 15 KiB |
|
After Width: | Height: | Size: 31 KiB |
@@ -9,14 +9,15 @@ gmpy==1.17
|
||||
jsonrpc==1.2
|
||||
jsonrpclib==0.1.7
|
||||
https://github.com/lbryio/lbryum/tarball/master/#egg=lbryum
|
||||
leveldb==0.193
|
||||
loggly-python-handler==1.0.0
|
||||
miniupnpc==1.9
|
||||
pbkdf2==1.3
|
||||
protobuf==3.0.0b3
|
||||
protobuf==3.0.0
|
||||
pycrypto==2.6.1
|
||||
python-bitcoinrpc==0.1
|
||||
qrcode==5.2.2
|
||||
requests==2.9.1
|
||||
requests_futures==0.9.7
|
||||
seccure==0.3.1.3
|
||||
simplejson==3.8.2
|
||||
six==1.9.0
|
||||
@@ -26,3 +27,4 @@ unqlite==0.2.0
|
||||
wsgiref==0.1.2
|
||||
zope.interface==4.1.3
|
||||
base58==0.2.2
|
||||
googlefinance==0.7
|
||||
@@ -25,7 +25,11 @@ console_scripts = ['lbrynet-stdin-uploader = lbrynet.lbrynet_console.LBRYStdinUp
|
||||
|
||||
requires = ['pycrypto', 'twisted', 'miniupnpc', 'yapsy', 'seccure',
|
||||
'python-bitcoinrpc==0.1', 'txJSON-RPC', 'requests>=2.4.2', 'unqlite==0.2.0',
|
||||
'leveldb', 'lbryum', 'jsonrpc', 'simplejson', 'appdirs', 'six==1.9.0', 'base58']
|
||||
'leveldb', 'lbryum', 'jsonrpc', 'simplejson', 'appdirs', 'six==1.9.0', 'base58', 'googlefinance',
|
||||
'requests_futures']
|
||||
|
||||
if sys.platform.startswith("linux"):
|
||||
requires.append('service-identity')
|
||||
|
||||
setup(name='lbrynet',
|
||||
description='A decentralized media library and marketplace',
|
||||
|
||||
@@ -3,12 +3,27 @@
|
||||
To create local builds and distributable .msi, run the following command:
|
||||
python setup_win32.py build bdist_msi
|
||||
"""
|
||||
import opcode
|
||||
import os
|
||||
import pkg_resources
|
||||
import sys
|
||||
|
||||
from cx_Freeze import setup, Executable
|
||||
import requests.certs
|
||||
|
||||
from lbrynet import __version__
|
||||
|
||||
name = 'LBRY'
|
||||
description = 'A decentralized media library and marketplace'
|
||||
win_icon = os.path.join('packaging', 'windows', 'lbry-win32-app', 'icons', 'lbry256.ico')
|
||||
wordlist_path = pkg_resources.resource_filename('lbryum', 'wordlist')
|
||||
|
||||
base_dir = os.path.abspath(os.path.dirname(__file__))
|
||||
|
||||
# Allow virtualenv to find distutils of base python installation
|
||||
distutils_path = os.path.join(os.path.dirname(opcode.__file__), 'distutils')
|
||||
|
||||
|
||||
def find_data_file(filename):
|
||||
if getattr(sys, 'frozen', False):
|
||||
# The application is frozen
|
||||
@@ -19,72 +34,117 @@ def find_data_file(filename):
|
||||
data_dir = os.path.dirname(__file__)
|
||||
return os.path.join(data_dir, filename)
|
||||
|
||||
shortcut_table = [
|
||||
('DesktopShortcut', # Shortcut
|
||||
'DesktopFolder', # Directory
|
||||
'LBRY', # Name
|
||||
'TARGETDIR', # Component
|
||||
'[TARGETDIR]\LBRY.exe', # Target
|
||||
None, # Arguments
|
||||
None, # Description
|
||||
None, # Hotkey
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'lbry-dark-icon.ico'), # Icon
|
||||
None, # IconIndex
|
||||
None, # ShowCmd
|
||||
'TARGETDIR', # WkDir
|
||||
),
|
||||
]
|
||||
console_scripts = ['lbrynet-stdin-uploader = lbrynet.lbrynet_console.LBRYStdinUploader:launch_stdin_uploader',
|
||||
'lbrynet-stdout-downloader = lbrynet.lbrynet_console.LBRYStdoutDownloader:launch_stdout_downloader',
|
||||
'lbrynet-create-network = lbrynet.create_network:main',
|
||||
'lbrynet-launch-node = lbrynet.dht.node:main',
|
||||
'lbrynet-launch-rpc-node = lbrynet.rpc_node:main',
|
||||
'lbrynet-rpc-node-cli = lbrynet.node_rpc_cli:main',
|
||||
'lbrynet-lookup-hosts-for-hash = lbrynet.dht_scripts:get_hosts_for_hash_in_dht',
|
||||
'lbrynet-announce_hash_to_dht = lbrynet.dht_scripts:announce_hash_to_dht',
|
||||
'lbrynet-daemon = lbrynet.lbrynet_daemon.LBRYDaemonControl:start',
|
||||
'stop-lbrynet-daemon = lbrynet.lbrynet_daemon.LBRYDaemonControl:stop',
|
||||
'lbrynet-cli = lbrynet.lbrynet_daemon.LBRYDaemonCLI:main']
|
||||
|
||||
# Now create the table dictionary
|
||||
msi_data = {'Shortcut': shortcut_table}
|
||||
# shortcut_table = [
|
||||
# ('DesktopShortcut', # Shortcut
|
||||
# 'DesktopFolder', # Directory
|
||||
# name, # Name
|
||||
# 'TARGETDIR', # Component
|
||||
# '[TARGETDIR]\{0}.exe'.format(name), # Target
|
||||
# None, # Arguments
|
||||
# description, # Description
|
||||
# None, # Hotkey
|
||||
# win_icon, # Icon (doesn't work for some reason?)
|
||||
# None, # IconIndex
|
||||
# None, # ShowCmd
|
||||
# 'TARGETDIR', # WkDir
|
||||
# ),
|
||||
# ]
|
||||
#
|
||||
# msi_data = {'Shortcut': shortcut_table}
|
||||
|
||||
bdist_msi_options = {
|
||||
'upgrade_code': '{66620F3A-DC3A-11E2-B341-002219E9B01F}',
|
||||
'upgrade_code': '{18c0e933-ad08-44e8-a413-1d0ed624c100}',
|
||||
'add_to_path': False,
|
||||
'initial_target_dir': r'[LocalAppDataFolder]\LBRY',
|
||||
'data': msi_data,
|
||||
# Default install path is 'C:\Program Files\' for 32-bit or 'C:\Program Files (x86)\' for 64-bit
|
||||
# 'initial_target_dir': r'[LocalAppDataFolder]\{0}'.format(name),
|
||||
# 'data': msi_data
|
||||
}
|
||||
|
||||
build_exe_options = {
|
||||
'include_msvcr': True,
|
||||
'includes': [],
|
||||
'packages': ['six', 'os', 'twisted', 'miniupnpc', 'unqlite', 'seccure',
|
||||
'requests', 'bitcoinrpc', 'txjsonrpc', 'win32api', 'Crypto',
|
||||
'gmpy', 'yapsy', 'lbryum', 'google.protobuf'],
|
||||
'excludes': ['zope.interface._zope_interface_coptimizations'],
|
||||
'include_files': [os.path.join('lbrynet', 'lbrynet_gui', 'close.gif'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'close1.png'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'close2.gif'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'drop_down.gif'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'hide_options.gif'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'lbry-dark-242x80.gif'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'lbry-dark-icon.ico'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'lbry-dark-icon.xbm'),
|
||||
os.path.join('lbrynet', 'lbrynet_gui', 'show_options.gif'),
|
||||
os.path.join('lbrycrdd.exe'), # Not included in repo
|
||||
os.path.join('lbrycrd-cli.exe'), # Not included in repo
|
||||
(requests.certs.where(), 'cacert.pem'),
|
||||
'packages': ['cython',
|
||||
'twisted',
|
||||
'yapsy',
|
||||
'appdirs',
|
||||
'argparse',
|
||||
'base58',
|
||||
'colorama',
|
||||
'cx_Freeze',
|
||||
'dns',
|
||||
'ecdsa',
|
||||
'gmpy',
|
||||
'googlefinance',
|
||||
'jsonrpc',
|
||||
'jsonrpclib',
|
||||
'lbryum',
|
||||
'loggly',
|
||||
'miniupnpc',
|
||||
'pbkdf2',
|
||||
'google.protobuf',
|
||||
'Crypto',
|
||||
'bitcoinrpc',
|
||||
'win32api',
|
||||
'qrcode',
|
||||
'requests',
|
||||
'requests_futures',
|
||||
'seccure',
|
||||
'simplejson',
|
||||
'six',
|
||||
'aes',
|
||||
'txjsonrpc',
|
||||
'unqlite',
|
||||
'wsgiref',
|
||||
'zope.interface',
|
||||
'os',
|
||||
'pkg_resources'
|
||||
],
|
||||
'excludes': ['distutils', 'collections.sys', 'collections._weakref', 'collections.abc',
|
||||
'Tkinter', 'tk', 'tcl', 'PyQt4', 'nose', 'mock'
|
||||
'zope.interface._zope_interface_coptimizations'],
|
||||
'include_files': [(distutils_path, 'distutils'), (requests.certs.where(), 'cacert.pem'),
|
||||
(os.path.join('packaging', 'windows', 'lbry-win32-app', 'icons', 'lbry16.ico'),
|
||||
os.path.join('icons', 'lbry16.ico')),
|
||||
(os.path.join(wordlist_path, 'chinese_simplified.txt'),
|
||||
os.path.join('wordlist', 'chinese_simplified.txt')),
|
||||
(os.path.join(wordlist_path, 'english.txt'), os.path.join('wordlist', 'english.txt')),
|
||||
(os.path.join(wordlist_path, 'japanese.txt'), os.path.join('wordlist', 'japanese.txt')),
|
||||
(os.path.join(wordlist_path, 'portuguese.txt'), os.path.join('wordlist', 'portuguese.txt')),
|
||||
(os.path.join(wordlist_path, 'spanish.txt'), os.path.join('wordlist', 'spanish.txt'))
|
||||
],
|
||||
'namespace_packages': ['zope']}
|
||||
'namespace_packages': ['zope', 'google']}
|
||||
|
||||
exe = Executable(
|
||||
script=os.path.join('lbrynet', 'lbrynet_gui', 'gui.py'),
|
||||
script=os.path.join('packaging', 'windows', 'lbry-win32-app', 'LBRYWin32App.py'),
|
||||
base='Win32GUI',
|
||||
icon=os.path.join('lbrynet', 'lbrynet_gui', 'lbry-dark-icon.ico'),
|
||||
icon=win_icon,
|
||||
compress=True,
|
||||
shortcutName='LBRY',
|
||||
shortcutName=name,
|
||||
shortcutDir='DesktopFolder',
|
||||
targetName='LBRY.exe'
|
||||
targetName='{0}.exe'.format(name)
|
||||
# targetDir="LocalAppDataFolder"
|
||||
)
|
||||
|
||||
setup(
|
||||
name='LBRY',
|
||||
version='0.0.4',
|
||||
description='A fully decentralized network for distributing data',
|
||||
name=name,
|
||||
version=__version__,
|
||||
description=name + ": " + description,
|
||||
url='lbry.io',
|
||||
author='',
|
||||
author='LBRY, Inc.',
|
||||
keywords='LBRY',
|
||||
data_files=[],
|
||||
options={'build_exe': build_exe_options,
|
||||
'bdist_msi': bdist_msi_options},
|
||||
executables=[exe],
|
||||
|
||||
@@ -0,0 +1,194 @@
|
||||
import os
|
||||
import shutil
|
||||
|
||||
from twisted.internet import defer, threads, error
|
||||
from twisted.trial import unittest
|
||||
|
||||
from lbrynet import conf
|
||||
from lbrynet import lbryfile
|
||||
from lbrynet import reflector
|
||||
from lbrynet.core import BlobManager
|
||||
from lbrynet.core import PeerManager
|
||||
from lbrynet.core import RateLimiter
|
||||
from lbrynet.core import Session
|
||||
from lbrynet.core import StreamDescriptor
|
||||
from lbrynet.lbryfile import LBRYFileMetadataManager
|
||||
from lbrynet.lbryfile.client import LBRYFileOptions
|
||||
from lbrynet.lbryfilemanager import LBRYFileCreator
|
||||
from lbrynet.lbryfilemanager import LBRYFileManager
|
||||
|
||||
from tests import mocks
|
||||
|
||||
|
||||
class TestReflector(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.session = None
|
||||
self.stream_info_manager = None
|
||||
self.lbry_file_manager = None
|
||||
self.server_blob_manager = None
|
||||
self.reflector_port = None
|
||||
self.addCleanup(self.take_down_env)
|
||||
|
||||
def take_down_env(self):
|
||||
d = defer.succeed(True)
|
||||
if self.lbry_file_manager is not None:
|
||||
d.addCallback(lambda _: self.lbry_file_manager.stop())
|
||||
if self.session is not None:
|
||||
d.addCallback(lambda _: self.session.shut_down())
|
||||
if self.stream_info_manager is not None:
|
||||
d.addCallback(lambda _: self.stream_info_manager.stop())
|
||||
if self.server_blob_manager is not None:
|
||||
d.addCallback(lambda _: self.server_blob_manager.stop())
|
||||
if self.reflector_port is not None:
|
||||
d.addCallback(lambda _: self.reflector_port.stopListening())
|
||||
|
||||
def delete_test_env():
|
||||
try:
|
||||
shutil.rmtree('client')
|
||||
except:
|
||||
raise unittest.SkipTest("TODO: fix this for windows")
|
||||
|
||||
d.addCallback(lambda _: threads.deferToThread(delete_test_env))
|
||||
d.addErrback(lambda err: str(err))
|
||||
return d
|
||||
|
||||
def test_reflector(self):
|
||||
wallet = mocks.Wallet()
|
||||
peer_manager = PeerManager.PeerManager()
|
||||
peer_finder = mocks.PeerFinder(5553, peer_manager, 2)
|
||||
hash_announcer = mocks.Announcer()
|
||||
rate_limiter = RateLimiter.DummyRateLimiter()
|
||||
sd_identifier = StreamDescriptor.StreamDescriptorIdentifier()
|
||||
|
||||
self.expected_blobs = [
|
||||
(
|
||||
'dc4708f76a5e7af0f1cae0ee96b824e2ed9250c9346c093b'
|
||||
'441f0a20d3607c17948b6fcfb4bc62020fe5286693d08586',
|
||||
2097152
|
||||
),
|
||||
(
|
||||
'f4067522c1b49432a2a679512e3917144317caa1abba0c04'
|
||||
'1e0cd2cf9f635d4cf127ce1824fa04189b63916174951f70',
|
||||
2097152
|
||||
),
|
||||
(
|
||||
'305486c434260484fcb2968ce0e963b72f81ba56c11b08b1'
|
||||
'af0789b55b44d78422600f9a38e3cf4f2e9569897e5646a9',
|
||||
1015056
|
||||
),
|
||||
]
|
||||
|
||||
db_dir = "client"
|
||||
os.mkdir(db_dir)
|
||||
|
||||
self.session = Session.LBRYSession(
|
||||
conf.MIN_BLOB_DATA_PAYMENT_RATE,
|
||||
db_dir=db_dir,
|
||||
lbryid="abcd",
|
||||
peer_finder=peer_finder,
|
||||
hash_announcer=hash_announcer,
|
||||
blob_dir=None,
|
||||
peer_port=5553,
|
||||
use_upnp=False,
|
||||
rate_limiter=rate_limiter,
|
||||
wallet=wallet
|
||||
)
|
||||
|
||||
self.stream_info_manager = LBRYFileMetadataManager.TempLBRYFileMetadataManager()
|
||||
|
||||
self.lbry_file_manager = LBRYFileManager.LBRYFileManager(
|
||||
self.session, self.stream_info_manager, sd_identifier)
|
||||
|
||||
self.server_blob_manager = BlobManager.TempBlobManager(hash_announcer)
|
||||
|
||||
d = self.session.setup()
|
||||
d.addCallback(lambda _: self.stream_info_manager.setup())
|
||||
d.addCallback(lambda _: LBRYFileOptions.add_lbry_file_to_sd_identifier(sd_identifier))
|
||||
d.addCallback(lambda _: self.lbry_file_manager.setup())
|
||||
d.addCallback(lambda _: self.server_blob_manager.setup())
|
||||
|
||||
def verify_equal(sd_info):
|
||||
self.assertEqual(mocks.create_stream_sd_file, sd_info)
|
||||
|
||||
def save_sd_blob_hash(sd_hash):
|
||||
self.expected_blobs.append((sd_hash, 923))
|
||||
|
||||
def verify_stream_descriptor_file(stream_hash):
|
||||
d = lbryfile.get_sd_info(self.lbry_file_manager.stream_info_manager, stream_hash, True)
|
||||
d.addCallback(verify_equal)
|
||||
d.addCallback(
|
||||
lambda _: lbryfile.publish_sd_blob(
|
||||
self.lbry_file_manager.stream_info_manager,
|
||||
self.session.blob_manager, stream_hash
|
||||
)
|
||||
)
|
||||
d.addCallback(save_sd_blob_hash)
|
||||
d.addCallback(lambda _: stream_hash)
|
||||
return d
|
||||
|
||||
def create_stream():
|
||||
test_file = mocks.GenFile(5209343, b''.join([chr(i + 3) for i in xrange(0, 64, 6)]))
|
||||
d = LBRYFileCreator.create_lbry_file(
|
||||
self.session,
|
||||
self.lbry_file_manager,
|
||||
"test_file",
|
||||
test_file,
|
||||
key="0123456701234567",
|
||||
iv_generator=iv_generator()
|
||||
)
|
||||
return d
|
||||
|
||||
def start_server():
|
||||
server_factory = reflector.ServerFactory(peer_manager, self.server_blob_manager)
|
||||
from twisted.internet import reactor
|
||||
port = 8943
|
||||
while self.reflector_port is None:
|
||||
try:
|
||||
self.reflector_port = reactor.listenTCP(port, server_factory)
|
||||
except error.CannotListenError:
|
||||
port += 1
|
||||
return defer.succeed(port)
|
||||
|
||||
def send_to_server(port, stream_hash):
|
||||
factory = reflector.ClientFactory(
|
||||
self.session.blob_manager,
|
||||
self.stream_info_manager,
|
||||
stream_hash
|
||||
)
|
||||
|
||||
from twisted.internet import reactor
|
||||
reactor.connectTCP('localhost', port, factory)
|
||||
return factory.finished_deferred
|
||||
|
||||
def verify_blob_completed(blob, blob_size):
|
||||
self.assertTrue(blob.is_validated())
|
||||
self.assertEqual(blob_size, blob.length)
|
||||
|
||||
def verify_have_blob(blob_hash, blob_size):
|
||||
d = self.server_blob_manager.get_blob(blob_hash, True)
|
||||
d.addCallback(lambda blob: verify_blob_completed(blob, blob_size))
|
||||
return d
|
||||
|
||||
def verify_data_on_reflector():
|
||||
check_blob_ds = []
|
||||
for blob_hash, blob_size in self.expected_blobs:
|
||||
check_blob_ds.append(verify_have_blob(blob_hash, blob_size))
|
||||
return defer.DeferredList(check_blob_ds)
|
||||
|
||||
def upload_to_reflector(stream_hash):
|
||||
d = start_server()
|
||||
d.addCallback(lambda port: send_to_server(port, stream_hash))
|
||||
d.addCallback(lambda _: verify_data_on_reflector())
|
||||
return d
|
||||
|
||||
d.addCallback(lambda _: create_stream())
|
||||
d.addCallback(verify_stream_descriptor_file)
|
||||
d.addCallback(upload_to_reflector)
|
||||
return d
|
||||
|
||||
|
||||
def iv_generator():
|
||||
iv = 0
|
||||
while True:
|
||||
iv += 1
|
||||
yield "%016d" % iv
|
||||
@@ -26,7 +26,7 @@ from lbrynet.core.StreamDescriptor import download_sd_blob
|
||||
from lbrynet.lbryfilemanager.LBRYFileCreator import create_lbry_file
|
||||
from lbrynet.lbryfile.client.LBRYFileOptions import add_lbry_file_to_sd_identifier
|
||||
from lbrynet.lbryfile.StreamDescriptor import get_sd_info
|
||||
from twisted.internet import defer, threads, task
|
||||
from twisted.internet import defer, threads, task, error
|
||||
from twisted.trial.unittest import TestCase
|
||||
from twisted.python.failure import Failure
|
||||
import os
|
||||
@@ -38,6 +38,10 @@ from lbrynet.core.server.ServerProtocol import ServerProtocolFactory
|
||||
from lbrynet.lbrylive.server.LiveBlobInfoQueryHandler import CryptBlobInfoQueryHandlerFactory
|
||||
from lbrynet.lbrylive.client.LiveStreamOptions import add_live_stream_to_sd_identifier
|
||||
from lbrynet.lbrylive.client.LiveStreamDownloader import add_full_live_stream_downloader_to_sd_identifier
|
||||
from lbrynet.core.BlobManager import TempBlobManager
|
||||
from lbrynet.reflector.client.client import LBRYFileReflectorClientFactory
|
||||
from lbrynet.reflector.server.server import ReflectorServerFactory
|
||||
from lbrynet.lbryfile.StreamDescriptor import publish_sd_blob
|
||||
|
||||
|
||||
log_format = "%(funcName)s(): %(message)s"
|
||||
@@ -1369,4 +1373,147 @@ class TestStreamify(TestCase):
|
||||
d.addCallback(lambda _: self.lbry_file_manager.setup())
|
||||
d.addCallback(lambda _: create_stream())
|
||||
d.addCallback(combine_stream)
|
||||
return d
|
||||
|
||||
|
||||
class TestReflector(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.session = None
|
||||
self.stream_info_manager = None
|
||||
self.lbry_file_manager = None
|
||||
self.server_blob_manager = None
|
||||
self.reflector_port = None
|
||||
self.addCleanup(self.take_down_env)
|
||||
|
||||
def take_down_env(self):
|
||||
|
||||
d = defer.succeed(True)
|
||||
if self.lbry_file_manager is not None:
|
||||
d.addCallback(lambda _: self.lbry_file_manager.stop())
|
||||
if self.session is not None:
|
||||
d.addCallback(lambda _: self.session.shut_down())
|
||||
if self.stream_info_manager is not None:
|
||||
d.addCallback(lambda _: self.stream_info_manager.stop())
|
||||
if self.server_blob_manager is not None:
|
||||
d.addCallback(lambda _: self.server_blob_manager.stop())
|
||||
if self.reflector_port is not None:
|
||||
d.addCallback(lambda _: self.reflector_port.stopListening())
|
||||
|
||||
def delete_test_env():
|
||||
shutil.rmtree('client')
|
||||
|
||||
d.addCallback(lambda _: threads.deferToThread(delete_test_env))
|
||||
return d
|
||||
|
||||
def test_reflector(self):
|
||||
|
||||
wallet = FakeWallet()
|
||||
peer_manager = PeerManager()
|
||||
peer_finder = FakePeerFinder(5553, peer_manager, 2)
|
||||
hash_announcer = FakeAnnouncer()
|
||||
rate_limiter = DummyRateLimiter()
|
||||
sd_identifier = StreamDescriptorIdentifier()
|
||||
|
||||
self.expected_blobs = [
|
||||
('dc4708f76a5e7af0f1cae0ee96b824e2ed9250c9346c093b'
|
||||
'441f0a20d3607c17948b6fcfb4bc62020fe5286693d08586', 2097152),
|
||||
('f4067522c1b49432a2a679512e3917144317caa1abba0c04'
|
||||
'1e0cd2cf9f635d4cf127ce1824fa04189b63916174951f70', 2097152),
|
||||
('305486c434260484fcb2968ce0e963b72f81ba56c11b08b1'
|
||||
'af0789b55b44d78422600f9a38e3cf4f2e9569897e5646a9', 1015056),
|
||||
]
|
||||
|
||||
db_dir = "client"
|
||||
os.mkdir(db_dir)
|
||||
|
||||
self.session = LBRYSession(MIN_BLOB_DATA_PAYMENT_RATE, db_dir=db_dir, lbryid="abcd",
|
||||
peer_finder=peer_finder, hash_announcer=hash_announcer,
|
||||
blob_dir=None, peer_port=5553,
|
||||
use_upnp=False, rate_limiter=rate_limiter, wallet=wallet)
|
||||
|
||||
self.stream_info_manager = TempLBRYFileMetadataManager()
|
||||
|
||||
self.lbry_file_manager = LBRYFileManager(self.session, self.stream_info_manager, sd_identifier)
|
||||
|
||||
self.server_blob_manager = TempBlobManager(hash_announcer)
|
||||
|
||||
d = self.session.setup()
|
||||
d.addCallback(lambda _: self.stream_info_manager.setup())
|
||||
d.addCallback(lambda _: add_lbry_file_to_sd_identifier(sd_identifier))
|
||||
d.addCallback(lambda _: self.lbry_file_manager.setup())
|
||||
d.addCallback(lambda _: self.server_blob_manager.setup())
|
||||
|
||||
def verify_equal(sd_info):
|
||||
self.assertEqual(sd_info, test_create_stream_sd_file)
|
||||
|
||||
def save_sd_blob_hash(sd_hash):
|
||||
self.expected_blobs.append((sd_hash, 923))
|
||||
|
||||
def verify_stream_descriptor_file(stream_hash):
|
||||
d = get_sd_info(self.lbry_file_manager.stream_info_manager, stream_hash, True)
|
||||
d.addCallback(verify_equal)
|
||||
d.addCallback(lambda _: publish_sd_blob(self.lbry_file_manager.stream_info_manager, self.session.blob_manager, stream_hash))
|
||||
d.addCallback(save_sd_blob_hash)
|
||||
d.addCallback(lambda _: stream_hash)
|
||||
return d
|
||||
|
||||
def iv_generator():
|
||||
iv = 0
|
||||
while 1:
|
||||
iv += 1
|
||||
yield "%016d" % iv
|
||||
|
||||
def create_stream():
|
||||
test_file = GenFile(5209343, b''.join([chr(i + 3) for i in xrange(0, 64, 6)]))
|
||||
d = create_lbry_file(self.session, self.lbry_file_manager, "test_file", test_file,
|
||||
key="0123456701234567", iv_generator=iv_generator())
|
||||
return d
|
||||
|
||||
def start_server():
|
||||
server_factory = ReflectorServerFactory(peer_manager, self.server_blob_manager)
|
||||
from twisted.internet import reactor
|
||||
port = 8943
|
||||
while self.reflector_port is None:
|
||||
try:
|
||||
self.reflector_port = reactor.listenTCP(port, server_factory)
|
||||
except error.CannotListenError:
|
||||
port += 1
|
||||
return defer.succeed(port)
|
||||
|
||||
def send_to_server(port, stream_hash):
|
||||
factory = LBRYFileReflectorClientFactory(
|
||||
self.session.blob_manager,
|
||||
self.stream_info_manager,
|
||||
stream_hash
|
||||
)
|
||||
|
||||
from twisted.internet import reactor
|
||||
reactor.connectTCP('localhost', port, factory)
|
||||
return factory.finished_deferred
|
||||
|
||||
def verify_blob_completed(blob, blob_size):
|
||||
self.assertTrue(blob.is_validated())
|
||||
self.assertEqual(blob_size, blob.length)
|
||||
|
||||
def verify_have_blob(blob_hash, blob_size):
|
||||
d = self.server_blob_manager.get_blob(blob_hash, True)
|
||||
d.addCallback(lambda blob: verify_blob_completed(blob, blob_size))
|
||||
return d
|
||||
|
||||
def verify_data_on_reflector():
|
||||
check_blob_ds = []
|
||||
for blob_hash, blob_size in self.expected_blobs:
|
||||
check_blob_ds.append(verify_have_blob(blob_hash, blob_size))
|
||||
return defer.DeferredList(check_blob_ds)
|
||||
|
||||
def upload_to_reflector(stream_hash):
|
||||
d = start_server()
|
||||
d.addCallback(lambda port: send_to_server(port, stream_hash))
|
||||
d.addCallback(lambda _: verify_data_on_reflector())
|
||||
return d
|
||||
|
||||
d.addCallback(lambda _: create_stream())
|
||||
d.addCallback(verify_stream_descriptor_file)
|
||||
d.addCallback(upload_to_reflector)
|
||||
return d
|
||||
@@ -0,0 +1,164 @@
|
||||
import io
|
||||
|
||||
from Crypto.PublicKey import RSA
|
||||
from twisted.internet import defer, threads, task, error
|
||||
|
||||
from lbrynet.core import PTCWallet
|
||||
|
||||
|
||||
class Node(object):
|
||||
def __init__(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def joinNetwork(self, *args):
|
||||
pass
|
||||
|
||||
def stop(self):
|
||||
pass
|
||||
|
||||
|
||||
class Wallet(object):
|
||||
def __init__(self):
|
||||
self.private_key = RSA.generate(1024)
|
||||
self.encoded_public_key = self.private_key.publickey().exportKey()
|
||||
|
||||
def start(self):
|
||||
return defer.succeed(True)
|
||||
|
||||
def stop(self):
|
||||
return defer.succeed(True)
|
||||
|
||||
def get_info_exchanger(self):
|
||||
return PTCWallet.PointTraderKeyExchanger(self)
|
||||
|
||||
def get_wallet_info_query_handler_factory(self):
|
||||
return PTCWallet.PointTraderKeyQueryHandlerFactory(self)
|
||||
|
||||
def reserve_points(self, *args):
|
||||
return True
|
||||
|
||||
def cancel_point_reservation(self, *args):
|
||||
pass
|
||||
|
||||
def send_points(self, *args):
|
||||
return defer.succeed(True)
|
||||
|
||||
def add_expected_payment(self, *args):
|
||||
pass
|
||||
|
||||
def get_balance(self):
|
||||
return defer.succeed(1000)
|
||||
|
||||
def set_public_key_for_peer(self, peer, public_key):
|
||||
pass
|
||||
|
||||
|
||||
class PeerFinder(object):
|
||||
def __init__(self, start_port, peer_manager, num_peers):
|
||||
self.start_port = start_port
|
||||
self.peer_manager = peer_manager
|
||||
self.num_peers = num_peers
|
||||
self.count = 0
|
||||
|
||||
def find_peers_for_blob(self, *args):
|
||||
peer_port = self.start_port + self.count
|
||||
self.count += 1
|
||||
if self.count >= self.num_peers:
|
||||
self.count = 0
|
||||
return defer.succeed([self.peer_manager.get_peer("127.0.0.1", peer_port)])
|
||||
|
||||
def run_manage_loop(self):
|
||||
pass
|
||||
|
||||
def stop(self):
|
||||
pass
|
||||
|
||||
|
||||
class Announcer(object):
|
||||
def __init__(self, *args):
|
||||
pass
|
||||
|
||||
def add_supplier(self, supplier):
|
||||
pass
|
||||
|
||||
def immediate_announce(self, *args):
|
||||
pass
|
||||
|
||||
def run_manage_loop(self):
|
||||
pass
|
||||
|
||||
def stop(self):
|
||||
pass
|
||||
|
||||
|
||||
class GenFile(io.RawIOBase):
|
||||
def __init__(self, size, pattern):
|
||||
io.RawIOBase.__init__(self)
|
||||
self.size = size
|
||||
self.pattern = pattern
|
||||
self.read_so_far = 0
|
||||
self.buff = b''
|
||||
self.last_offset = 0
|
||||
|
||||
def readable(self):
|
||||
return True
|
||||
|
||||
def writable(self):
|
||||
return False
|
||||
|
||||
def read(self, n=-1):
|
||||
if n > -1:
|
||||
bytes_to_read = min(n, self.size - self.read_so_far)
|
||||
else:
|
||||
bytes_to_read = self.size - self.read_so_far
|
||||
output, self.buff = self.buff[:bytes_to_read], self.buff[bytes_to_read:]
|
||||
bytes_to_read -= len(output)
|
||||
while bytes_to_read > 0:
|
||||
self.buff = self._generate_chunk()
|
||||
new_output, self.buff = self.buff[:bytes_to_read], self.buff[bytes_to_read:]
|
||||
bytes_to_read -= len(new_output)
|
||||
output += new_output
|
||||
self.read_so_far += len(output)
|
||||
return output
|
||||
|
||||
def readall(self):
|
||||
return self.read()
|
||||
|
||||
def _generate_chunk(self, n=2**10):
|
||||
output = self.pattern[self.last_offset:self.last_offset + n]
|
||||
n_left = n - len(output)
|
||||
whole_patterns = n_left / len(self.pattern)
|
||||
output += self.pattern * whole_patterns
|
||||
self.last_offset = n - len(output)
|
||||
output += self.pattern[:self.last_offset]
|
||||
return output
|
||||
|
||||
|
||||
create_stream_sd_file = {
|
||||
'stream_name': '746573745f66696c65',
|
||||
'blobs': [
|
||||
{
|
||||
'length': 2097152,
|
||||
'blob_num': 0,
|
||||
'blob_hash': 'dc4708f76a5e7af0f1cae0ee96b824e2ed9250c9346c093b441f0a20d3607c17948b6fcfb4bc62020fe5286693d08586',
|
||||
'iv': '30303030303030303030303030303031'
|
||||
},
|
||||
{
|
||||
'length': 2097152,
|
||||
'blob_num': 1,
|
||||
'blob_hash': 'f4067522c1b49432a2a679512e3917144317caa1abba0c041e0cd2cf9f635d4cf127ce1824fa04189b63916174951f70',
|
||||
'iv': '30303030303030303030303030303032'
|
||||
},
|
||||
{
|
||||
'length': 1015056,
|
||||
'blob_num': 2,
|
||||
'blob_hash': '305486c434260484fcb2968ce0e963b72f81ba56c11b08b1af0789b55b44d78422600f9a38e3cf4f2e9569897e5646a9',
|
||||
'iv': '30303030303030303030303030303033'
|
||||
},
|
||||
{'length': 0, 'blob_num': 3, 'iv': '30303030303030303030303030303034'}
|
||||
],
|
||||
'stream_type': 'lbryfile',
|
||||
'key': '30313233343536373031323334353637',
|
||||
'suggested_file_name': '746573745f66696c65',
|
||||
'stream_hash': '6d27fbe10c86d81aacfb897c7a426d0a2214f5a299455a6d315c0f998c4b3545c2dc60906122d94653c23b1898229e3f'
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
import mock
|
||||
from lbrynet.metadata import LBRYMetadata
|
||||
from lbrynet.lbrynet_daemon import LBRYExchangeRateManager
|
||||
|
||||
from twisted.trial import unittest
|
||||
|
||||
|
||||
class LBRYFeeFormatTest(unittest.TestCase):
|
||||
def test_fee_created_with_correct_inputs(self):
|
||||
fee_dict = {
|
||||
'USD': {
|
||||
'amount': 10.0,
|
||||
'address': "bRcHraa8bYJZL7vkh5sNmGwPDERFUjGPP9"
|
||||
}
|
||||
}
|
||||
fee = LBRYMetadata.LBRYFeeValidator(fee_dict)
|
||||
self.assertEqual(10.0, fee['USD']['amount'])
|
||||
|
||||
|
||||
class LBRYFeeTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
patcher = mock.patch('time.time')
|
||||
self.time = patcher.start()
|
||||
self.time.return_value = 0
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_fee_converts_to_lbc(self):
|
||||
fee_dict = {
|
||||
'USD': {
|
||||
'amount': 10.0,
|
||||
'address': "bRcHraa8bYJZL7vkh5sNmGwPDERFUjGPP9"
|
||||
}
|
||||
}
|
||||
rates = {'BTCLBC': {'spot': 3.0, 'ts': 2}, 'USDBTC': {'spot': 2.0, 'ts': 3}}
|
||||
manager = LBRYExchangeRateManager.DummyExchangeRateManager(rates)
|
||||
self.assertEqual(60.0, manager.to_lbc(fee_dict).amount)
|
||||
@@ -0,0 +1,203 @@
|
||||
from lbrynet.metadata import LBRYMetadata
|
||||
from twisted.trial import unittest
|
||||
|
||||
|
||||
class MetadataTest(unittest.TestCase):
|
||||
def test_assertion_if_no_metadata(self):
|
||||
metadata = {}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata)
|
||||
|
||||
def test_assertion_if_source_is_missing(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'title': "It's a Disaster",
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg',
|
||||
}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata)
|
||||
|
||||
def test_metadata_works_without_fee(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'title': "It's a Disaster",
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8d0d6ea64d09f5aa90faf5807d8a761c32a27047861e06f81f41e35623a348a4b0104052161d5f89cf190f9672bc4ead'},
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg',
|
||||
}
|
||||
m = LBRYMetadata.Metadata(metadata)
|
||||
self.assertFalse('fee' in m)
|
||||
|
||||
def test_assertion_if_invalid_source(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'title': "It's a Disaster",
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'sources': {
|
||||
'fake': 'source'},
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg',
|
||||
}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata)
|
||||
|
||||
def test_assertion_if_missing_v001_field(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'fee': {'LBC': {'amount': 50.0, 'address': 'bRQJASJrDbFZVAvcpv3NoNWoH74LQd5JNV'}},
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8d0d6ea64d09f5aa90faf5807d8a761c32a27047861e06f81f41e35623a348a4b0104052161d5f89cf190f9672bc4ead'},
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg'
|
||||
}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata)
|
||||
|
||||
def test_version_is_001_if_all_fields_are_present(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'title': "It's a Disaster",
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8d0d6ea64d09f5aa90faf5807d8a761c32a27047861e06f81f41e35623a348a4b0104052161d5f89cf190f9672bc4ead'},
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg',
|
||||
}
|
||||
m = LBRYMetadata.Metadata(metadata, process_now=False)
|
||||
self.assertEquals('0.0.1', m.version)
|
||||
|
||||
def test_assertion_if_there_is_an_extra_field(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'title': "It's a Disaster",
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8d0d6ea64d09f5aa90faf5807d8a761c32a27047861e06f81f41e35623a348a4b0104052161d5f89cf190f9672bc4ead'},
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg',
|
||||
'MYSTERYFIELD': '?'
|
||||
}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata, process_now=False)
|
||||
|
||||
def test_version_is_002_if_all_fields_are_present(self):
|
||||
metadata = {
|
||||
'license': 'NASA',
|
||||
'fee': {'USD': {'amount': 0.01, 'address': 'baBYSK7CqGSn5KrEmNmmQwAhBSFgo6v47z'}},
|
||||
'ver': '0.0.2',
|
||||
'description': 'SDO captures images of the sun in 10 different wavelengths, each of which helps highlight a different temperature of solar material. Different temperatures can, in turn, show specific structures on the sun such as solar flares, which are gigantic explosions of light and x-rays, or coronal loops, which are stream of solar material travelling up and down looping magnetic field lines',
|
||||
'language': 'en',
|
||||
'author': 'The SDO Team, Genna Duberstein and Scott Wiessinger',
|
||||
'title': 'Thermonuclear Art',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8655f713819344980a9a0d67b198344e2c462c90f813e86f0c63789ab0868031f25c54d0bb31af6658e997e2041806eb'},
|
||||
'nsfw': False,
|
||||
'content-type': 'video/mp4',
|
||||
'thumbnail': 'https://svs.gsfc.nasa.gov/vis/a010000/a012000/a012034/Combined.00_08_16_17.Still004.jpg'
|
||||
}
|
||||
m = LBRYMetadata.Metadata(metadata, process_now=False)
|
||||
self.assertEquals('0.0.2', m.version)
|
||||
|
||||
def test_version_is_003_if_all_fields_are_present(self):
|
||||
metadata = {
|
||||
'license': 'NASA',
|
||||
'fee': {'USD': {'amount': 0.01, 'address': 'baBYSK7CqGSn5KrEmNmmQwAhBSFgo6v47z'}},
|
||||
'ver': '0.0.3',
|
||||
'description': 'SDO captures images of the sun in 10 different wavelengths, each of which helps highlight a different temperature of solar material. Different temperatures can, in turn, show specific structures on the sun such as solar flares, which are gigantic explosions of light and x-rays, or coronal loops, which are stream of solar material travelling up and down looping magnetic field lines',
|
||||
'language': 'en',
|
||||
'author': 'The SDO Team, Genna Duberstein and Scott Wiessinger',
|
||||
'title': 'Thermonuclear Art',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8655f713819344980a9a0d67b198344e2c462c90f813e86f0c63789ab0868031f25c54d0bb31af6658e997e2041806eb'},
|
||||
'nsfw': False,
|
||||
'content_type': 'video/mp4',
|
||||
'thumbnail': 'https://svs.gsfc.nasa.gov/vis/a010000/a012000/a012034/Combined.00_08_16_17.Still004.jpg'
|
||||
}
|
||||
m = LBRYMetadata.Metadata(metadata, process_now=False)
|
||||
self.assertEquals('0.0.3', m.version)
|
||||
|
||||
def test_version_claimed_is_001_but_version_is_002(self):
|
||||
metadata = {
|
||||
'license': 'NASA',
|
||||
'fee': {'USD': {'amount': 0.01, 'address': 'baBYSK7CqGSn5KrEmNmmQwAhBSFgo6v47z'}},
|
||||
'ver': '0.0.1',
|
||||
'description': 'SDO captures images of the sun in 10 different wavelengths, each of which helps highlight a different temperature of solar material. Different temperatures can, in turn, show specific structures on the sun such as solar flares, which are gigantic explosions of light and x-rays, or coronal loops, which are stream of solar material travelling up and down looping magnetic field lines',
|
||||
'language': 'en',
|
||||
'author': 'The SDO Team, Genna Duberstein and Scott Wiessinger',
|
||||
'title': 'Thermonuclear Art',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8655f713819344980a9a0d67b198344e2c462c90f813e86f0c63789ab0868031f25c54d0bb31af6658e997e2041806eb'},
|
||||
'nsfw': False,
|
||||
'content-type': 'video/mp4',
|
||||
'thumbnail': 'https://svs.gsfc.nasa.gov/vis/a010000/a012000/a012034/Combined.00_08_16_17.Still004.jpg'
|
||||
}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata, process_now=False)
|
||||
|
||||
def test_version_claimed_is_002_but_version_is_003(self):
|
||||
metadata = {
|
||||
'license': 'NASA',
|
||||
'fee': {'USD': {'amount': 0.01, 'address': 'baBYSK7CqGSn5KrEmNmmQwAhBSFgo6v47z'}},
|
||||
'ver': '0.0.2',
|
||||
'description': 'SDO captures images of the sun in 10 different wavelengths, each of which helps highlight a different temperature of solar material. Different temperatures can, in turn, show specific structures on the sun such as solar flares, which are gigantic explosions of light and x-rays, or coronal loops, which are stream of solar material travelling up and down looping magnetic field lines',
|
||||
'language': 'en',
|
||||
'author': 'The SDO Team, Genna Duberstein and Scott Wiessinger',
|
||||
'title': 'Thermonuclear Art',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8655f713819344980a9a0d67b198344e2c462c90f813e86f0c63789ab0868031f25c54d0bb31af6658e997e2041806eb'},
|
||||
'nsfw': False,
|
||||
'content_type': 'video/mp4',
|
||||
'thumbnail': 'https://svs.gsfc.nasa.gov/vis/a010000/a012000/a012034/Combined.00_08_16_17.Still004.jpg'
|
||||
}
|
||||
with self.assertRaises(AssertionError):
|
||||
LBRYMetadata.Metadata(metadata, process_now=False)
|
||||
|
||||
def test_version_001_ports_to_003(self):
|
||||
metadata = {
|
||||
'license': 'Oscilloscope Laboratories',
|
||||
'description': 'Four couples meet for Sunday brunch only to discover they are stuck in a house together as the world may be about to end.',
|
||||
'language': 'en',
|
||||
'title': "It's a Disaster",
|
||||
'author': 'Written and directed by Todd Berger',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8d0d6ea64d09f5aa90faf5807d8a761c32a27047861e06f81f41e35623a348a4b0104052161d5f89cf190f9672bc4ead'},
|
||||
'content-type': 'audio/mpeg',
|
||||
'thumbnail': 'http://ia.media-imdb.com/images/M/MV5BMTQwNjYzMTQ0Ml5BMl5BanBnXkFtZTcwNDUzODM5Nw@@._V1_SY1000_CR0,0,673,1000_AL_.jpg',
|
||||
}
|
||||
m = LBRYMetadata.Metadata(metadata, process_now=True)
|
||||
self.assertEquals('0.0.3', m.version)
|
||||
|
||||
def test_version_002_ports_to_003(self):
|
||||
metadata = {
|
||||
'license': 'NASA',
|
||||
'fee': {'USD': {'amount': 0.01, 'address': 'baBYSK7CqGSn5KrEmNmmQwAhBSFgo6v47z'}},
|
||||
'ver': '0.0.2',
|
||||
'description': 'SDO captures images of the sun in 10 different wavelengths, each of which helps highlight a different temperature of solar material. Different temperatures can, in turn, show specific structures on the sun such as solar flares, which are gigantic explosions of light and x-rays, or coronal loops, which are stream of solar material travelling up and down looping magnetic field lines',
|
||||
'language': 'en',
|
||||
'author': 'The SDO Team, Genna Duberstein and Scott Wiessinger',
|
||||
'title': 'Thermonuclear Art',
|
||||
'sources': {
|
||||
'lbry_sd_hash': '8655f713819344980a9a0d67b198344e2c462c90f813e86f0c63789ab0868031f25c54d0bb31af6658e997e2041806eb'},
|
||||
'nsfw': False,
|
||||
'content-type': 'video/mp4',
|
||||
'thumbnail': 'https://svs.gsfc.nasa.gov/vis/a010000/a012000/a012034/Combined.00_08_16_17.Still004.jpg'
|
||||
}
|
||||
m = LBRYMetadata.Metadata(metadata, process_now=True)
|
||||
self.assertEquals('0.0.3', m.version)
|
||||
@@ -0,0 +1,30 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from lbrynet.core import utils
|
||||
|
||||
from twisted.trial import unittest
|
||||
|
||||
|
||||
class CompareVersionTest(unittest.TestCase):
|
||||
def test_compare_versions_isnot_lexographic(self):
|
||||
self.assertTrue(utils.version_is_greater_than('0.3.10', '0.3.6'))
|
||||
|
||||
def test_same_versions_return_false(self):
|
||||
self.assertFalse(utils.version_is_greater_than('1.3.9', '1.3.9'))
|
||||
|
||||
def test_same_release_is_greater_then_beta(self):
|
||||
self.assertTrue(utils.version_is_greater_than('1.3.9', '1.3.9b1'))
|
||||
|
||||
def test_version_can_have_four_parts(self):
|
||||
self.assertTrue(utils.version_is_greater_than('1.3.9.1', '1.3.9'))
|
||||
|
||||
|
||||
class ObfuscationTest(unittest.TestCase):
|
||||
def test_deobfuscation_reverses_obfuscation(self):
|
||||
plain = "my_test_string"
|
||||
obf = utils.obfuscate(plain)
|
||||
self.assertEqual(plain, utils.deobfuscate(obf))
|
||||
|
||||
def test_can_use_unicode(self):
|
||||
plain = '☃'
|
||||
obf = utils.obfuscate(plain)
|
||||
self.assertEqual(plain, utils.deobfuscate(obf))
|
||||
@@ -0,0 +1,38 @@
|
||||
import mock
|
||||
import requests
|
||||
from twisted.trial import unittest
|
||||
|
||||
from lbrynet.lbrynet_daemon import LBRYDaemon
|
||||
|
||||
|
||||
class MiscTests(unittest.TestCase):
|
||||
def test_get_lbrynet_version_from_github(self):
|
||||
response = mock.create_autospec(requests.Response)
|
||||
# don't need to mock out the entire response from the api
|
||||
# but at least need 'tag_name'
|
||||
response.json.return_value = {
|
||||
"url": "https://api.github.com/repos/lbryio/lbry/releases/3685199",
|
||||
"assets_url": "https://api.github.com/repos/lbryio/lbry/releases/3685199/assets",
|
||||
"html_url": "https://github.com/lbryio/lbry/releases/tag/v0.3.8",
|
||||
"id": 3685199,
|
||||
"tag_name": "v0.3.8",
|
||||
"prerelease": False
|
||||
}
|
||||
with mock.patch('lbrynet.lbrynet_daemon.LBRYDaemon.requests') as req:
|
||||
req.get.return_value = response
|
||||
self.assertEqual('0.3.8', LBRYDaemon.get_lbrynet_version_from_github())
|
||||
|
||||
def test_error_is_thrown_if_prerelease(self):
|
||||
response = mock.create_autospec(requests.Response)
|
||||
response.json.return_value = {
|
||||
"tag_name": "v0.3.8",
|
||||
"prerelease": True
|
||||
}
|
||||
with mock.patch('lbrynet.lbrynet_daemon.LBRYDaemon.requests') as req:
|
||||
req.get.return_value = response
|
||||
with self.assertRaises(Exception):
|
||||
LBRYDaemon.get_lbrynet_version_from_github()
|
||||
|
||||
def test_error_is_thrown_when_version_cant_be_parsed(self):
|
||||
with self.assertRaises(Exception):
|
||||
LBRYDaemon.get_version_from_tag('garbage')
|
||||