a

2019-10-15 20:27:10 +05:00 · 2019-09-26 18:07:17 +05:00 · 2019-09-26 17:54:05 +05:00 · 2019-09-22 23:51:33 +05:00 · 2019-09-17 11:51:42 +05:00 · 2019-09-17 11:49:40 +05:00
10 changed files with 854 additions and 231 deletions
--- a/.gitmodules
+++ b/.gitmodules
--- a/17
+++ b/17
@ -3,21 +3,20 @@ name = "pypi"
 url = "https://pypi.org/simple"
 verify_ssl = true

-[dev-packages]
-prospector = "*"
-
 [packages]
 pyotp = "*"
 python-decouple = "*"
 requests = "*"
 flask = "*"
 flask-restful = "*"
-grpcio = "*"
-etcd3 = "*"
-gunicorn = "*"
 bitmath = "*"
-pylint = "*"
-transitions = "*"
+ucloud-common = {editable = true,git = "git+https://code.ungleich.ch/ucloud/ucloud_common.git",ref = "wip"}
+etcd3-wrapper = {editable = true,git = "git+https://code.ungleich.ch/ungleich-public/etcd3_wrapper.git",ref = "wip"}
+python-etcd3 = {editable = true,git = "git+https://github.com/kragniz/python-etcd3.git"}

 [requires]
-python_version = "3.7"
+python_version = "3.5"
+
+[dev-packages]
+pylint = "*"
+flake8 = "*"
--- a/Pipfile.lock
+++ b/Pipfile.lock
@ -0,0 +1,373 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "8f4fea75ee93add161c854e35b118720363a0ad30504dc9d9504cc24f7bcab91"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "3.5"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "aniso8601": {
+            "hashes": [
+                "sha256:529dcb1f5f26ee0df6c0a1ee84b7b27197c3c50fc3a6321d66c544689237d072",
+                "sha256:c033f63d028b9a58e3ab0c2c7d0532ab4bfa7452bfc788fbfe3ddabd327b181a"
+            ],
+            "version": "==8.0.0"
+        },
+        "bitmath": {
+            "hashes": [
+                "sha256:293325f01e65defe966853111df11d39215eb705a967cb115851da8c4cfa3eb8"
+            ],
+            "index": "pypi",
+            "version": "==1.3.3.1"
+        },
+        "certifi": {
+            "hashes": [
+                "sha256:e4f3620cfea4f83eedc95b24abd9cd56f3c4b146dd0177e83a21b4eb49e21e50",
+                "sha256:fd7c7c74727ddcf00e9acd26bba8da604ffec95bf1c2144e67aff7a8b50e6cef"
+            ],
+            "version": "==2019.9.11"
+        },
+        "chardet": {
+            "hashes": [
+                "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae",
+                "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"
+            ],
+            "version": "==3.0.4"
+        },
+        "click": {
+            "hashes": [
+                "sha256:2335065e6395b9e67ca716de5f7526736bfa6ceead690adf616d925bdc622b13",
+                "sha256:5b94b49521f6456670fdb30cd82a4eca9412788a93fa6dd6df72c94d5a8ff2d7"
+            ],
+            "version": "==7.0"
+        },
+        "etcd3-wrapper": {
+            "editable": true,
+            "git": "https://code.ungleich.ch/ungleich-public/etcd3_wrapper.git",
+            "ref": "76fb0bdf797199e9ea161dad1d004eea9b4520f8"
+        },
+        "flask": {
+            "hashes": [
+                "sha256:13f9f196f330c7c2c5d7a5cf91af894110ca0215ac051b5844701f2bfd934d52",
+                "sha256:45eb5a6fd193d6cf7e0cf5d8a5b31f83d5faae0293695626f539a823e93b13f6"
+            ],
+            "index": "pypi",
+            "version": "==1.1.1"
+        },
+        "flask-restful": {
+            "hashes": [
+                "sha256:ecd620c5cc29f663627f99e04f17d1f16d095c83dc1d618426e2ad68b03092f8",
+                "sha256:f8240ec12349afe8df1db168ea7c336c4e5b0271a36982bff7394f93275f2ca9"
+            ],
+            "index": "pypi",
+            "version": "==0.3.7"
+        },
+        "grpcio": {
+            "hashes": [
+                "sha256:0302331e014fc4bac028b6ad480b33f7abfe20b9bdcca7be417124dda8f22115",
+                "sha256:0aa0cce9c5eb1261b32173a20ed42b51308d55ce28ecc2021e868b3cb90d9503",
+                "sha256:0c83947575300499adbc308e986d754e7f629be0bdd9bea1ffdd5cf76e1f1eff",
+                "sha256:0ca26ff968d45efd4ef73447c4d4b34322ea8c7d06fbb6907ce9e5db78f1bbcb",
+                "sha256:0cf80a7955760c2498f8821880242bb657d70998065ff0d2a082de5ffce230a7",
+                "sha256:0d40706e57d9833fe0e023a08b468f33940e8909affa12547874216d36bba208",
+                "sha256:11872069156de34c6f3f9a1deb46cc88bc35dfde88262c4c73eb22b39b16fc55",
+                "sha256:16065227faae0ab0abf1789bfb92a2cd2ab5da87630663f93f8178026da40e0d",
+                "sha256:1e33778277685f6fabb22539136269c87c029e39b6321ef1a639b756a1c0a408",
+                "sha256:2b16be15b1ae656bc7a36642b8c7045be2dde2048bb4b67478003e9d9db8022a",
+                "sha256:3701dfca3ada27ceef0d17f728ce9dfef155ed20c57979c2b05083082258c6c1",
+                "sha256:41912ecaf482abf2de74c69f509878f99223f5dd6b2de1a09c955afd4de3cf9b",
+                "sha256:4332cbd20544fe7406910137590f38b5b3a1f6170258e038652cf478c639430f",
+                "sha256:44068ecbdc6467c2bff4d8198816c8a2701b6dd1ec16078fceb6adc7c1f577d6",
+                "sha256:53115960e37059420e2d16a4b04b00dd2ab3b6c3c67babd01ffbfdcd7881a69b",
+                "sha256:6e7027bcd4070414751e2a5e60706facb98a1fc636497c9bac5442fe37b8ae6b",
+                "sha256:6ff57fb2f07b7226b5bec89e8e921ea9bd220f35f11e094f2ba38f09eecd49c6",
+                "sha256:73240e244d7644654bbda1f309f4911748b6a1804b7a8897ddbe8a04c90f7407",
+                "sha256:785234bbc469bc75e26c868789a2080ffb30bd6e93930167797729889ad06b0b",
+                "sha256:82f9d3c7f91d2d1885631335c003c5d45ae1cd69cc0bc4893f21fef50b8151bc",
+                "sha256:86bdc2a965510658407a1372eb61f0c92f763fdfb2795e4d038944da4320c950",
+                "sha256:95e925b56676a55e6282b3de80a1cbad5774072159779c61eac02791dface049",
+                "sha256:96673bb4f14bd3263613526d1e7e33fdb38a9130e3ce87bf52314965706e1900",
+                "sha256:970014205e76920484679035b6fb4b16e02fc977e5aac4d22025da849c79dab9",
+                "sha256:ace5e8bf11a1571f855f5dab38a9bd34109b6c9bc2864abf24a597598c7e3695",
+                "sha256:ad375f03eb3b9cb75a24d91eab8609e134d34605f199efc41e20dd642bdac855",
+                "sha256:b819c4c7dcf0de76788ce5f95daad6d4e753d6da2b6a5f84e5bb5b5ce95fddc4",
+                "sha256:c17943fd340cbd906db49f3f03c7545e5a66b617e8348b2c7a0d2c759d216af1",
+                "sha256:d21247150dea86dabd3b628d8bc4b563036db3d332b3f4db3c5b1b0b122cb4f6",
+                "sha256:d4d500a7221116de9767229ff5dd10db91f789448d85befb0adf5a37b0cd83b5",
+                "sha256:e2a942a3cfccbbca21a90c144867112698ef36486345c285da9e98c466f22b22",
+                "sha256:e983273dca91cb8a5043bc88322eb48e2b8d4e4998ff441a1ee79ced89db3909"
+            ],
+            "version": "==1.24.1"
+        },
+        "idna": {
+            "hashes": [
+                "sha256:c357b3f628cf53ae2c4c05627ecc484553142ca23264e593d327bcde5e9c3407",
+                "sha256:ea8b7f6188e6fa117537c3df7da9fc686d485087abf6ac197f9c46432f7e4a3c"
+            ],
+            "version": "==2.8"
+        },
+        "itsdangerous": {
+            "hashes": [
+                "sha256:321b033d07f2a4136d3ec762eac9f16a10ccd60f53c0c91af90217ace7ba1f19",
+                "sha256:b12271b2047cb23eeb98c8b5622e2e5c5e9abd9784a153e9d8ef9cb4dd09d749"
+            ],
+            "version": "==1.1.0"
+        },
+        "jinja2": {
+            "hashes": [
+                "sha256:74320bb91f31270f9551d46522e33af46a80c3d619f4a4bf42b3164d30b5911f",
+                "sha256:9fe95f19286cfefaa917656583d020be14e7859c6b0252588391e47db34527de"
+            ],
+            "version": "==2.10.3"
+        },
+        "markupsafe": {
+            "hashes": [
+                "sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473",
+                "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161",
+                "sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235",
+                "sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5",
+                "sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff",
+                "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b",
+                "sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1",
+                "sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e",
+                "sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183",
+                "sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66",
+                "sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1",
+                "sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1",
+                "sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e",
+                "sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b",
+                "sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905",
+                "sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735",
+                "sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d",
+                "sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e",
+                "sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d",
+                "sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c",
+                "sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21",
+                "sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2",
+                "sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5",
+                "sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b",
+                "sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6",
+                "sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f",
+                "sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f",
+                "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7"
+            ],
+            "version": "==1.1.1"
+        },
+        "protobuf": {
+            "hashes": [
+                "sha256:125713564d8cfed7610e52444c9769b8dcb0b55e25cc7841f2290ee7bc86636f",
+                "sha256:1accdb7a47e51503be64d9a57543964ba674edac103215576399d2d0e34eac77",
+                "sha256:27003d12d4f68e3cbea9eb67427cab3bfddd47ff90670cb367fcd7a3a89b9657",
+                "sha256:3264f3c431a631b0b31e9db2ae8c927b79fc1a7b1b06b31e8e5bcf2af91fe896",
+                "sha256:3c5ab0f5c71ca5af27143e60613729e3488bb45f6d3f143dc918a20af8bab0bf",
+                "sha256:45dcf8758873e3f69feab075e5f3177270739f146255225474ee0b90429adef6",
+                "sha256:56a77d61a91186cc5676d8e11b36a5feb513873e4ae88d2ee5cf530d52bbcd3b",
+                "sha256:5984e4947bbcef5bd849d6244aec507d31786f2dd3344139adc1489fb403b300",
+                "sha256:6b0441da73796dd00821763bb4119674eaf252776beb50ae3883bed179a60b2a",
+                "sha256:6f6677c5ade94d4fe75a912926d6796d5c71a2a90c2aeefe0d6f211d75c74789",
+                "sha256:84a825a9418d7196e2acc48f8746cf1ee75877ed2f30433ab92a133f3eaf8fbe",
+                "sha256:b842c34fe043ccf78b4a6cf1019d7b80113707d68c88842d061fa2b8fb6ddedc",
+                "sha256:ca33d2f09dae149a1dcf942d2d825ebb06343b77b437198c9e2ef115cf5d5bc1",
+                "sha256:db83b5c12c0cd30150bb568e6feb2435c49ce4e68fe2d7b903113f0e221e58fe",
+                "sha256:f50f3b1c5c1c1334ca7ce9cad5992f098f460ffd6388a3cabad10b66c2006b09",
+                "sha256:f99f127909731cafb841c52f9216e447d3e4afb99b17bebfad327a75aee206de"
+            ],
+            "version": "==3.10.0"
+        },
+        "pyotp": {
+            "hashes": [
+                "sha256:c88f37fd47541a580b744b42136f387cdad481b560ef410c0d85c957eb2a2bc0",
+                "sha256:fc537e8acd985c5cbf51e11b7d53c42276fee017a73aec7c07380695671ca1a1"
+            ],
+            "index": "pypi",
+            "version": "==2.3.0"
+        },
+        "python-decouple": {
+            "hashes": [
+                "sha256:1317df14b43efee4337a4aa02914bf004f010cd56d6c4bd894e6474ec8c4fe2d"
+            ],
+            "index": "pypi",
+            "version": "==3.1"
+        },
+        "python-etcd3": {
+            "editable": true,
+            "git": "https://github.com/kragniz/python-etcd3.git",
+            "ref": "247e3952d0b47324091a36ace3ad9717469fb6b9"
+        },
+        "pytz": {
+            "hashes": [
+                "sha256:1c557d7d0e871de1f5ccd5833f60fb2550652da6be2693c1e02300743d21500d",
+                "sha256:b02c06db6cf09c12dd25137e563b31700d3b80fcc4ad23abb7a315f2789819be"
+            ],
+            "version": "==2019.3"
+        },
+        "requests": {
+            "hashes": [
+                "sha256:11e007a8a2aa0323f5a921e9e6a2d7e4e67d9877e85773fba9ba6419025cbeb4",
+                "sha256:9cf5292fcd0f598c671cfc1e0d7d1a7f13bb8085e9a590f48c010551dc6c4b31"
+            ],
+            "index": "pypi",
+            "version": "==2.22.0"
+        },
+        "six": {
+            "hashes": [
+                "sha256:3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c",
+                "sha256:d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"
+            ],
+            "version": "==1.12.0"
+        },
+        "tenacity": {
+            "hashes": [
+                "sha256:6a7511a59145c2e319b7d04ddd93c12d48cc3d3c8fa42c2846d33a620ee91f57",
+                "sha256:a4eb168dbf55ed2cae27e7c6b2bd48ab54dabaf294177d998330cf59f294c112"
+            ],
+            "version": "==5.1.1"
+        },
+        "ucloud-common": {
+            "editable": true,
+            "git": "https://code.ungleich.ch/ucloud/ucloud_common.git",
+            "ref": "0976a3e2ef648564483e69e89a530f55be630e08"
+        },
+        "urllib3": {
+            "hashes": [
+                "sha256:3de946ffbed6e6746608990594d08faac602528ac7015ac28d33cee6a45b7398",
+                "sha256:9a107b99a5393caf59c7aa3c1249c16e6879447533d0887f4336dde834c7be86"
+            ],
+            "version": "==1.25.6"
+        },
+        "werkzeug": {
+            "hashes": [
+                "sha256:7280924747b5733b246fe23972186c6b348f9ae29724135a6dfc1e53cea433e7",
+                "sha256:e5f4a1f98b52b18a93da705a7458e55afb26f32bff83ff5d19189f92462d65c4"
+            ],
+            "version": "==0.16.0"
+        }
+    },
+    "develop": {
+        "astroid": {
+            "hashes": [
+                "sha256:98c665ad84d10b18318c5ab7c3d203fe11714cbad2a4aef4f44651f415392754",
+                "sha256:b7546ffdedbf7abcfbff93cd1de9e9980b1ef744852689decc5aeada324238c6"
+            ],
+            "version": "==2.3.1"
+        },
+        "entrypoints": {
+            "hashes": [
+                "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19",
+                "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451"
+            ],
+            "version": "==0.3"
+        },
+        "flake8": {
+            "hashes": [
+                "sha256:19241c1cbc971b9962473e4438a2ca19749a7dd002dd1a946eaba171b4114548",
+                "sha256:8e9dfa3cecb2400b3738a42c54c3043e821682b9c840b0448c0503f781130696"
+            ],
+            "index": "pypi",
+            "version": "==3.7.8"
+        },
+        "isort": {
+            "hashes": [
+                "sha256:54da7e92468955c4fceacd0c86bd0ec997b0e1ee80d97f67c35a78b719dccab1",
+                "sha256:6e811fcb295968434526407adb8796944f1988c5b65e8139058f2014cbe100fd"
+            ],
+            "version": "==4.3.21"
+        },
+        "lazy-object-proxy": {
+            "hashes": [
+                "sha256:02b260c8deb80db09325b99edf62ae344ce9bc64d68b7a634410b8e9a568edbf",
+                "sha256:18f9c401083a4ba6e162355873f906315332ea7035803d0fd8166051e3d402e3",
+                "sha256:1f2c6209a8917c525c1e2b55a716135ca4658a3042b5122d4e3413a4030c26ce",
+                "sha256:2f06d97f0ca0f414f6b707c974aaf8829c2292c1c497642f63824119d770226f",
+                "sha256:616c94f8176808f4018b39f9638080ed86f96b55370b5a9463b2ee5c926f6c5f",
+                "sha256:63b91e30ef47ef68a30f0c3c278fbfe9822319c15f34b7538a829515b84ca2a0",
+                "sha256:77b454f03860b844f758c5d5c6e5f18d27de899a3db367f4af06bec2e6013a8e",
+                "sha256:83fe27ba321e4cfac466178606147d3c0aa18e8087507caec78ed5a966a64905",
+                "sha256:84742532d39f72df959d237912344d8a1764c2d03fe58beba96a87bfa11a76d8",
+                "sha256:874ebf3caaf55a020aeb08acead813baf5a305927a71ce88c9377970fe7ad3c2",
+                "sha256:9f5caf2c7436d44f3cec97c2fa7791f8a675170badbfa86e1992ca1b84c37009",
+                "sha256:a0c8758d01fcdfe7ae8e4b4017b13552efa7f1197dd7358dc9da0576f9d0328a",
+                "sha256:a4def978d9d28cda2d960c279318d46b327632686d82b4917516c36d4c274512",
+                "sha256:ad4f4be843dace866af5fc142509e9b9817ca0c59342fdb176ab6ad552c927f5",
+                "sha256:ae33dd198f772f714420c5ab698ff05ff900150486c648d29951e9c70694338e",
+                "sha256:b4a2b782b8a8c5522ad35c93e04d60e2ba7f7dcb9271ec8e8c3e08239be6c7b4",
+                "sha256:c462eb33f6abca3b34cdedbe84d761f31a60b814e173b98ede3c81bb48967c4f",
+                "sha256:fd135b8d35dfdcdb984828c84d695937e58cc5f49e1c854eb311c4d6aa03f4f1"
+            ],
+            "version": "==1.4.2"
+        },
+        "mccabe": {
+            "hashes": [
+                "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
+                "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"
+            ],
+            "version": "==0.6.1"
+        },
+        "pycodestyle": {
+            "hashes": [
+                "sha256:95a2219d12372f05704562a14ec30bc76b05a5b297b21a5dfe3f6fac3491ae56",
+                "sha256:e40a936c9a450ad81df37f549d676d127b1b66000a6c500caa2b085bc0ca976c"
+            ],
+            "version": "==2.5.0"
+        },
+        "pyflakes": {
+            "hashes": [
+                "sha256:17dbeb2e3f4d772725c777fabc446d5634d1038f234e77343108ce445ea69ce0",
+                "sha256:d976835886f8c5b31d47970ed689944a0262b5f3afa00a5a7b4dc81e5449f8a2"
+            ],
+            "version": "==2.1.1"
+        },
+        "pylint": {
+            "hashes": [
+                "sha256:7edbae11476c2182708063ac387a8f97c760d9cfe36a5ede0ca996f90cf346c8",
+                "sha256:844ce067788028c1a35086a5c66bc5e599ddd851841c41d6ee1623b36774d9f2"
+            ],
+            "index": "pypi",
+            "version": "==2.4.2"
+        },
+        "six": {
+            "hashes": [
+                "sha256:3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c",
+                "sha256:d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"
+            ],
+            "version": "==1.12.0"
+        },
+        "typed-ast": {
+            "hashes": [
+                "sha256:18511a0b3e7922276346bcb47e2ef9f38fb90fd31cb9223eed42c85d1312344e",
+                "sha256:262c247a82d005e43b5b7f69aff746370538e176131c32dda9cb0f324d27141e",
+                "sha256:2b907eb046d049bcd9892e3076c7a6456c93a25bebfe554e931620c90e6a25b0",
+                "sha256:354c16e5babd09f5cb0ee000d54cfa38401d8b8891eefa878ac772f827181a3c",
+                "sha256:4e0b70c6fc4d010f8107726af5fd37921b666f5b31d9331f0bd24ad9a088e631",
+                "sha256:630968c5cdee51a11c05a30453f8cd65e0cc1d2ad0d9192819df9978984529f4",
+                "sha256:66480f95b8167c9c5c5c87f32cf437d585937970f3fc24386f313a4c97b44e34",
+                "sha256:71211d26ffd12d63a83e079ff258ac9d56a1376a25bc80b1cdcdf601b855b90b",
+                "sha256:95bd11af7eafc16e829af2d3df510cecfd4387f6453355188342c3e79a2ec87a",
+                "sha256:bc6c7d3fa1325a0c6613512a093bc2a2a15aeec350451cbdf9e1d4bffe3e3233",
+                "sha256:cc34a6f5b426748a507dd5d1de4c1978f2eb5626d51326e43280941206c209e1",
+                "sha256:d755f03c1e4a51e9b24d899561fec4ccaf51f210d52abdf8c07ee2849b212a36",
+                "sha256:d7c45933b1bdfaf9f36c579671fec15d25b06c8398f113dab64c18ed1adda01d",
+                "sha256:d896919306dd0aa22d0132f62a1b78d11aaf4c9fc5b3410d3c666b818191630a",
+                "sha256:ffde2fbfad571af120fcbfbbc61c72469e72f550d676c3342492a9dfdefb8f12"
+            ],
+            "markers": "implementation_name == 'cpython' and python_version < '3.8'",
+            "version": "==1.4.0"
+        },
+        "wrapt": {
+            "hashes": [
+                "sha256:565a021fd19419476b9362b05eeaa094178de64f8361e44468f9e9d7843901e1"
+            ],
+            "version": "==1.11.2"
+        }
+    }
+}
--- a/README.md
+++ b/README.md
@ -3,31 +3,10 @@

 ## Installation

-**Make sure you have Python >= 3.6 and Pipenv installed.**
+**Make sure you have Python >= 3.5 and Pipenv installed.**

 1. Clone the repository and `cd` into it.
 2. Run the following commands
    - `pipenv install`
    - `pipenv shell`
    - `python main.py`
-
-## Endpoints
-
-### Create VM
-To Create VM send a `POST` request at `/vm/create` with JSON body.
-An Example JSON Request Body is shown below
-
-
-```json
-{
-	"name": "username",
-	"realm": "user realm",
-	"seed": "user seed",
-	"specs": {
-		"cpu": 16,
-		"ram": 256,
-		"hdd": "2TB",
-		"sdd": "256GB"
-	}
-}
-```
--- a/common_fields.py
+++ b/common_fields.py
@ -1,10 +1,14 @@
+import os
+
 from specs_parser import SpecsParser
 from config import etcd_client as client
+from config import VM_PREFIX
+

 specs_parser = SpecsParser(exceptional_devices=["cpu"])


-class Field(object):
+class Field:
    def __init__(self, _name, _type, _value=None):
        self.name = _name
        self.value = _value
@ -16,10 +20,10 @@ class Field(object):

    def is_valid(self):
        if self.value == KeyError:
-            self.add_error(f"'{self.name}' field is a required field")
+            self.add_error("'{}' field is a required field".format(self.name))
        else:
            if not isinstance(self.value, self.type):
-                self.add_error(f"Incorrect Type for '{self.name}' field")
+                self.add_error("Incorrect Type for '{}' field".format(self.name))
            else:
                self.validation()

@ -43,9 +47,9 @@ class VmUUIDField(Field):
        self.validation = self.vm_uuid_validation

    def vm_uuid_validation(self):
-        r = client.get(f"/v1/vm/{self.uuid}")
+        r = client.get(os.path.join(VM_PREFIX, self.uuid))
        if not r:
-            self.add_error(f"VM with uuid {self.uuid} does not exists")
+            self.add_error("VM with uuid {} does not exists".format(self.uuid))


 class SpecsField(Field):
@ -58,5 +62,7 @@ class SpecsField(Field):

    def specs_validation(self):
        if not specs_parser.transform_specs(self.specs):
-            self.add_error("Invalid unit - "
-                           f"Please use following units {specs_parser.get_allowed_units()}")
+            self.add_error(
+                "Invalid unit - "
+                "Please use following units {}".format(specs_parser.get_allowed_units())
+            )
--- a/config.py
+++ b/config.py
@ -3,6 +3,11 @@ import logging
 from etcd3_wrapper import Etcd3Wrapper
 from decouple import config

+
+from ucloud_common.vm import VmPool
+from ucloud_common.host import HostPool
+from ucloud_common.request import RequestPool
+
 logging.basicConfig(
    level=logging.DEBUG,
    filename="log.txt",
@ -13,5 +18,15 @@ logging.basicConfig(


 WITHOUT_CEPH = config("WITHOUT_CEPH", False, cast=bool)
+VM_PREFIX = config("VM_PREFIX")
+HOST_PREFIX = config("HOST_PREFIX")
+REQUEST_PREFIX = config("REQUEST_PREFIX")
+FILE_PREFIX = config("FILE_PREFIX")
+IMAGE_PREFIX = config("IMAGE_PREFIX")
+IMAGE_STORE_PREFIX = config("IMAGE_STORE_PREFIX")

 etcd_client = Etcd3Wrapper(host=config("ETCD_URL"))
+
+VM_POOL = VmPool(etcd_client, VM_PREFIX)
+HOST_POOL = HostPool(etcd_client, HOST_PREFIX)
+REQUEST_POOL = RequestPool(etcd_client, REQUEST_PREFIX)
--- a/create_image_store.py
+++ b/create_image_store.py
@ -1,21 +1,17 @@
 import json
-from uuid import uuid4
-from config import etcd_client as client
+import os

+from uuid import uuid4
+
+from config import etcd_client as client
+from config import IMAGE_STORE_PREFIX

 data = {
    "is_public": True,
    "type": "ceph",
    "name": "images",
    "description": "first ever public image-store",
-    "attributes": {
-        "list": [],
-        "key": [],
-        "pool": "images",
-    }
+    "attributes": {"list": [], "key": [], "pool": "images"},
 }

-client.put(
-    f"/v1/image_store/{uuid4().hex}",
-    json.dumps(data),
-)
+client.put(os.path.join(IMAGE_STORE_PREFIX, uuid4().hex), json.dumps(data))
--- a/helper.py
+++ b/helper.py
@ -3,6 +3,7 @@ import requests

 from decouple import config
 from pyotp import TOTP
+from config import VM_POOL


 def check_otp(name, realm, token):
@ -18,11 +19,27 @@ def check_otp(name, realm, token):
    except binascii.Error:
        return 400

-    response = requests.post(
+    response = requests.get(
        "{OTP_SERVER}{OTP_VERIFY_ENDPOINT}".format(
            OTP_SERVER=config("OTP_SERVER", ""),
-            OTP_VERIFY_ENDPOINT=config("OTP_VERIFY_ENDPOINT", "verify/"),
+            OTP_VERIFY_ENDPOINT=config("OTP_VERIFY_ENDPOINT", "verify"),
        ),
-        data=data,
+        json=data,
    )
    return response.status_code
+
+
+def resolve_vm_name(name, owner):
+    """
+    Input: name of vm, owner of vm
+    Output: uuid of vm if found otherwise None
+    """
+    result = next(
+        filter(
+            lambda vm: vm.value["owner"] == owner and vm.value["name"] == name,
+            VM_POOL.vms,
+        ),
+        None,
+    )
+    if result:
+        return result.key.split("/")[-1]
--- a/main.py
+++ b/main.py
@ -1,33 +1,45 @@
-# TODO
-#  1. Allow user of realm ungleich-admin to perform any action on
-#     any user vm.
-
+# TODO:  realm should be part of user's name. Because, there can be multiple
+#       name but with different realms. For Example, nico exists in both
+#       ungleich-admin and ungleich-twitter realm. So, to differentiate between
+#       them, we need to make realm part of user's name
 import json
 import subprocess
 import os

+from uuid import uuid4
+
 from flask import Flask, request
 from flask_restful import Resource, Api
-from uuid import uuid4
-from os.path import join
-from config import etcd_client as client
-from config import WITHOUT_CEPH, logging
+from ucloud_common.vm import VMStatus
+from ucloud_common.request import RequestEntry, RequestType

-from ucloud_common.vm import VmPool, VMStatus
-from ucloud_common.host import HostPool
-from ucloud_common.request import RequestEntry, RequestPool, RequestType
-from schemas import (CreateVMSchema, VMStatusSchema,
-                     CreateImageSchema, VmActionSchema,
-                     OTPSchema, CreateHostSchema,
-                     VmMigrationSchema)
+from config import etcd_client as client
+from config import (
+    WITHOUT_CEPH,
+    VM_PREFIX,
+    HOST_PREFIX,
+    FILE_PREFIX,
+    IMAGE_PREFIX,
+    logging,
+    REQUEST_POOL,
+    VM_POOL,
+    HOST_POOL,
+)
+from schemas import (
+    CreateVMSchema,
+    VMStatusSchema,
+    CreateImageSchema,
+    VmActionSchema,
+    OTPSchema,
+    CreateHostSchema,
+    VmMigrationSchema,
+    AddSSHSchema,
+    RemoveSSHSchema
+)

 app = Flask(__name__)
 api = Api(app)

-vm_pool = VmPool(client, "/v1/vm")
-host_pool = HostPool(client, "/v1/host")
-request_pool = RequestPool(client, "/v1/request")
-

 class CreateVM(Resource):
    @staticmethod
@ -35,29 +47,35 @@ class CreateVM(Resource):
        data = request.json
        validator = CreateVMSchema(data)
        if validator.is_valid():
-            # Create VM Entry under /v1/vm/
-            # TODO: !!!Generate Mac Address on creation of VM
            vm_uuid = uuid4().hex
-            vm_key = f"/v1/vm/{vm_uuid}"
+            vm_key = os.path.join(VM_PREFIX, vm_uuid)
+
+            specs = {
+                'cpu': validator.specs['cpu'],
+                'ram': validator.specs['ram'],
+                'os-ssd': validator.specs['os-ssd'],
+                'hdd': validator.specs['hdd']
+            }
+
            vm_entry = {
+                "name": data["vm_name"],
                "owner": data["name"],
-                "specs": data["specs"],
+                "specs": specs,
                "hostname": "",
                "status": "",
                "image_uuid": data["image_uuid"],
                "log": [],
-                "storage_attachment": []
+                "storage_attachment": [],
+                "vnc_socket": "",
            }
            client.put(vm_key, vm_entry, value_in_json=True)

            # Create ScheduleVM Request
-            r = RequestEntry.from_scratch(type=RequestType.ScheduleVM,
-                                          uuid=vm_uuid)
-            request_pool.put(r)
+            r = RequestEntry.from_scratch(type=RequestType.ScheduleVM, uuid=vm_uuid)
+            REQUEST_POOL.put(r)

            return {"message": "VM Creation Queued"}, 200
-        else:
-            return validator.get_errors(), 400
+        return validator.get_errors(), 400


 class VmStatus(Resource):
@ -66,7 +84,7 @@ class VmStatus(Resource):
        data = request.json
        validator = VMStatusSchema(data)
        if validator.is_valid():
-            vm = vm_pool.get(f"/v1/vm/{data['uuid']}")
+            vm = VM_POOL.get(os.path.join(VM_PREFIX, data["uuid"]))
            return str(vm)
        else:
            return validator.get_errors(), 400
@ -78,7 +96,7 @@ class CreateImage(Resource):
        data = request.json
        validator = CreateImageSchema(data)
        if validator.is_valid():
-            file_entry = client.get(f"/v1/file/{data['uuid']}")
+            file_entry = client.get(os.path.join(FILE_PREFIX, data["uuid"]))
            file_entry_value = json.loads(file_entry.value)

            image_entry_json = {
@ -89,21 +107,21 @@ class CreateImage(Resource):
                "store_name": data["image_store"],
                "visibility": "public",
            }
-            client.put(f"/v1/image/{data['uuid']}", json.dumps(image_entry_json))
+            client.put(
+                os.path.join(IMAGE_PREFIX, data["uuid"]), json.dumps(image_entry_json)
+            )

            return {"message": "Image successfully created"}
-        else:
-            return validator.get_errors(), 400
+        return validator.get_errors(), 400


 class ListPublicImages(Resource):
    @staticmethod
    def get():
-        images = client.get_prefix("/v1/image/")
+        images = client.get_prefix(IMAGE_PREFIX)
        r = {}
        for image in images:
            r[image.key.split("/")[-1]] = json.loads(image.value)
-
        return r, 200


@ -114,20 +132,23 @@ class VMAction(Resource):
        validator = VmActionSchema(data)

        if validator.is_valid():
-            vm_entry = vm_pool.get(f"/v1/vm/{data['uuid']}")
+            vm_entry = VM_POOL.get(os.path.join(VM_PREFIX, data["uuid"]))
            action = data["action"]

            if action == "start":
                vm_entry.status = VMStatus.requested_start
-                vm_pool.put(vm_entry)
+                VM_POOL.put(vm_entry)
                action = "schedule"

            if action == "delete" and vm_entry.hostname == "":
                try:
-                    path_without_protocol = vm_entry.path[vm_entry.path.find(":")+1:]
+                    path_without_protocol = vm_entry.path[vm_entry.path.find(":") + 1 :]

                    if WITHOUT_CEPH:
-                        command_to_delete = ["rm", os.path.join("/var/vm", vm_entry.uuid)]
+                        command_to_delete = [
+                            "rm",
+                            os.path.join("/var/vm", vm_entry.uuid),
+                        ]
                    else:
                        command_to_delete = ["rbd", "rm", path_without_protocol]

@ -143,11 +164,13 @@ class VMAction(Resource):
                    client.client.delete(vm_entry.key)
                    return {"message": "VM successfully deleted"}

-            r = RequestEntry.from_scratch(type=f"{action.title()}VM",
-                                          uuid=data['uuid'],
-                                          hostname=vm_entry.hostname)
-            request_pool.put(r)
-            return {"message": f"VM {action.title()} Queued"}, 200
+            r = RequestEntry.from_scratch(
+                type="{}VM".format(action.title()),
+                uuid=data["uuid"],
+                hostname=vm_entry.hostname,
+            )
+            REQUEST_POOL.put(r)
+            return {"message": "VM {} Queued".format(action.title())}, 200
        else:
            return validator.get_errors(), 400

@ -159,14 +182,16 @@ class VMMigration(Resource):
        validator = VmMigrationSchema(data)

        if validator.is_valid():
-            vm = vm_pool.get(data['uuid'])
+            vm = VM_POOL.get(data["uuid"])

-            r = RequestEntry.from_scratch(type=RequestType.ScheduleVM,
-                                          uuid=vm.uuid,
-                                          destination=join("/v1/host", data["destination"]),
-                                          migration=True)
-            request_pool.put(r)
-            return {"message": f"VM Migration Initialization Queued"}, 200
+            r = RequestEntry.from_scratch(
+                type=RequestType.ScheduleVM,
+                uuid=vm.uuid,
+                destination=os.path.join(HOST_PREFIX, data["destination"]),
+                migration=True,
+            )
+            REQUEST_POOL.put(r)
+            return {"message": "VM Migration Initialization Queued"}, 200
        else:
            return validator.get_errors(), 400

@ -178,22 +203,26 @@ class ListUserVM(Resource):
        validator = OTPSchema(data)

        if validator.is_valid():
-            vms = client.get_prefix(f"/v1/vm/", value_in_json=True)
-            if vms:
-                return_vms = []
-                user_vms = list(filter(lambda v: v.value["owner"] == data["name"], vms))
-                for vm in user_vms:
-                    return_vms.append(
-                        {
-                            "vm_uuid": vm.key.split("/")[-1],
-                            "specs": vm.value["specs"],
-                            "status": vm.value["status"],
-                            "hostname": vm.value["hostname"]
-                        }
-                    )
+            vms = client.get_prefix(VM_PREFIX, value_in_json=True)
+            return_vms = []
+            user_vms = filter(lambda v: v.value["owner"] == data["name"], vms)
+            for vm in user_vms:
+                return_vms.append(
+                    {
+                        "name": vm.value["name"],
+                        "vm_uuid": vm.key.split("/")[-1],
+                        "specs": vm.value["specs"],
+                        "status": vm.value["status"],
+                        "hostname": vm.value["hostname"],
+                        "vnc_socket": None
+                        if vm.value.get("vnc_socket", None) == None
+                        else vm.value["vnc_socket"],
+                    }
+                )
+            if return_vms:
                return {"message": return_vms}, 200
-            else:
-                return {"message": "No VM found"}, 404
+            return {"message": "No VM found"}, 404
+
        else:
            return validator.get_errors(), 400

@ -205,20 +234,17 @@ class ListUserFiles(Resource):
        validator = OTPSchema(data)

        if validator.is_valid():
-            files = client.get_prefix(f"/v1/file/", value_in_json=True)
-            if files:
-                return_files = []
-                user_files = list(filter(lambda f: f.value["owner"] == data["name"], files))
-                for file in user_files:
-                    return_files.append(
-                        {
-                            "filename": file.value["filename"],
-                            "uuid": file.key.split("/")[-1],
-                        }
-                    )
-                return {"message": return_files}, 200
-            else:
-                return {"message": "No File found"}, 404
+            files = client.get_prefix(FILE_PREFIX, value_in_json=True)
+            return_files = []
+            user_files = list(filter(lambda f: f.value["owner"] == data["name"], files))
+            for file in user_files:
+                return_files.append(
+                    {
+                        "filename": file.value["filename"],
+                        "uuid": file.key.split("/")[-1],
+                    }
+                )
+            return {"message": return_files}, 200
        else:
            return validator.get_errors(), 400

@ -229,7 +255,7 @@ class CreateHost(Resource):
        data = request.json
        validator = CreateHostSchema(data)
        if validator.is_valid():
-            host_key = f"/v1/host/{uuid4().hex}"
+            host_key = os.path.join(HOST_PREFIX, uuid4().hex)
            host_entry = {
                "specs": data["specs"],
                "hostname": data["hostname"],
@ -246,11 +272,63 @@ class CreateHost(Resource):
 class ListHost(Resource):
    @staticmethod
    def get():
-        hosts = host_pool.hosts
-        r = {host.key: {"status": host.status, "specs": host.specs, "hostname": host.hostname} for host in hosts}
+        hosts = HOST_POOL.hosts
+        r = {
+            host.key: {
+                "status": host.status,
+                "specs": host.specs,
+                "hostname": host.hostname,
+            }
+            for host in hosts
+        }
        return r, 200


+class AddSSHKey(Resource):
+    @staticmethod
+    def get():
+        data = request.json
+        validator = AddSSHSchema(data)
+        if validator.is_valid():
+            etcd_key = "/v1/user/{}/keys".format(data["name"])
+            etcd_entry = client.get(etcd_key, value_in_json=True)
+            if etcd_entry:
+                if data["key_name"] not in etcd_entry.value:
+                    etcd_entry.value[data["key_name"]] = data["key"]
+                    client.put(etcd_entry.key, etcd_entry.value, value_in_json=True)
+                else:
+                    return {"message": "Key with name '{}' already exists".format(data["key_name"])}
+            else:
+                # Key Not Found. It implies user' haven't added any key yet.
+                key_entry = {data["key_name"]: data["key"]}
+                client.put(etcd_key, key_entry, value_in_json=True)
+            
+            return {"message": "Key added successfully"}
+        else:
+            return validator.get_errors(), 400
+
+
+class RemoveSSHKey(Resource):
+    @staticmethod
+    def get():
+        data = request.json
+        validator = RemoveSSHSchema(data)
+        if validator.is_valid():
+            etcd_key = "/v1/user/{}/keys".format(data["name"])
+            etcd_entry = client.get(etcd_key, value_in_json=True)
+            if etcd_entry:
+                try:
+                    del etcd_entry.value[data["key_name"]]
+                except KeyError:
+                    return {"message": "No such key exists."}
+                else:
+                    client.put(etcd_entry.key, etcd_entry.value, value_in_json=True)
+                    return {"message": "Key successfully removed."}
+            else:
+                return {"message": "No Key Exists at all."}
+        else:
+            return validator.get_errors(), 400
+
 api.add_resource(CreateVM, "/vm/create")
 api.add_resource(VmStatus, "/vm/status")

@ -262,6 +340,8 @@ api.add_resource(ListPublicImages, "/image/list-public")

 api.add_resource(ListUserVM, "/user/vms")
 api.add_resource(ListUserFiles, "/user/files")
+api.add_resource(AddSSHKey, "/user/add-ssh")
+api.add_resource(RemoveSSHKey, "/user/remove-ssh")

 api.add_resource(CreateHost, "/host/create")
 api.add_resource(ListHost, "/host/list")
--- a/schemas.py
+++ b/schemas.py
@ -1,18 +1,39 @@
-import json
+"""
+This module contain classes thats validates and intercept/modify
+data coming from ucloud-cli (user)
+
+It was primarily developed as an alternative to argument parser
+of Flask_Restful which is going to be deprecated. I also tried
+marshmallow for that purpose but it was an overkill (because it
+do validation + serialization + deserialization) and little
+inflexible for our purpose.
+"""
+
+# TODO: Fix error message when user's mentioned VM (referred by name)
+#       does not exists.
+#
+#       Currently, it says uuid is a required field.
+
+import json
+import os
+import bitmath

-from common_fields import Field, VmUUIDField, SpecsField
 from ucloud_common.host import HostPool, HostStatus
 from ucloud_common.vm import VmPool, VMStatus
-from helper import check_otp
-from config import etcd_client as client
-from os.path import join

-host_pool = HostPool(client, "/v1/host")
-vm_pool = VmPool(client, "/v1/vm")
+from common_fields import Field, VmUUIDField, SpecsField
+from helper import check_otp, resolve_vm_name
+from config import etcd_client as client
+from config import (HOST_PREFIX, VM_PREFIX, IMAGE_PREFIX,
+                    FILE_PREFIX, IMAGE_STORE_PREFIX)
+
+HOST_POOL = HostPool(client, HOST_PREFIX)
+VM_POOL = VmPool(client, VM_PREFIX)


 class BaseSchema:
    def __init__(self, data, fields=None):
+        _ = data  # suppress linter warning
        self.__errors = []
        if fields is None:
            self.fields = []
@ -62,41 +83,17 @@ class OTPSchema(BaseSchema):
        super().__init__(data=data, fields=_fields)

    def validation(self):
-        rc = check_otp(self.name.value, self.realm.value, self.token.value)
-        if rc != 200:
+        if check_otp(self.name.value, self.realm.value, self.token.value) != 200:
            self.add_error("Wrong Credentials")


-class CreateVMSchema(OTPSchema):
-    def __init__(self, data):
-        self.specs = SpecsField(data)
-
-        self.image_uuid = Field("image_uuid", str, data.get("image_uuid", KeyError))
-        self.image_uuid.validation = self.image_uuid_validation
-
-        fields = [self.specs, self.image_uuid]
-        super().__init__(data=data, fields=fields)
-
-    def image_uuid_validation(self):
-        images = client.get_prefix("/v1/image/")
-
-        if self.image_uuid.value not in [i.key.split("/")[-1] for i in images]:
-            self.add_error("Image UUID not valid")
-
-
-class VMStatusSchema(BaseSchema):
-    def __init__(self, data):
-        self.uuid = VmUUIDField(data)
-
-        fields = [self.uuid]
-
-        super().__init__(data, fields)
+########################## Image Operations ###############################################


 class CreateImageSchema(BaseSchema):
    def __init__(self, data):
        # Fields
-        self.uuid: Field = Field("uuid", str, data.get("uuid", KeyError))
+        self.uuid = Field("uuid", str, data.get("uuid", KeyError))
        self.name = Field("name", str, data.get("name", KeyError))
        self.image_store = Field("image_store", str, data.get("image_store", KeyError))

@ -109,74 +106,27 @@ class CreateImageSchema(BaseSchema):
        super().__init__(data, fields)

    def file_uuid_validation(self):
-        file_entry = client.get(f"/v1/file/{self.uuid.value}")
+        file_entry = client.get(os.path.join(FILE_PREFIX, self.uuid.value))
        if file_entry is None:
-            self.add_error(f"Image File with uuid '{self.uuid.value}' Not Found")
+            self.add_error(
+                "Image File with uuid '{}' Not Found".format(self.uuid.value)
+            )

    def image_store_name_validation(self):
-        image_stores = list(client.get_prefix("/v1/image_store/"))
+        image_stores = list(client.get_prefix(IMAGE_STORE_PREFIX))

-        image_store = next(filter(lambda s: json.loads(s.value)["name"] == self.image_store.value,
-                                  image_stores), None)
+        image_store = next(
+            filter(
+                lambda s: json.loads(s.value)["name"] == self.image_store.value,
+                image_stores,
+            ),
+            None,
+        )
        if not image_store:
-            self.add_error(f"Store '{self.image_store.value}' does not exists")
+            self.add_error("Store '{}' does not exists".format(self.image_store.value))


-class VmActionSchema(OTPSchema):
-    def __init__(self, data):
-        self.uuid = VmUUIDField(data)
-        self.action = Field("action", str, data.get("action", KeyError))
-
-        self.action.validation = self.action_validation
-
-        _fields = [self.uuid, self.action]
-        super().__init__(data=data, fields=_fields)
-
-    def action_validation(self):
-        allowed_actions = ["start", "stop", "delete"]
-        if self.action.value not in allowed_actions:
-            self.add_error(f"Invalid Action. Allowed Actions are {allowed_actions}")
-
-    def validation(self):
-        vm = vm_pool.get(self.uuid.value)
-        if vm.value["owner"] != self.name.value:
-            self.add_error("Invalid User")
-
-        if self.action.value == "start" and vm.status == VMStatus.running and vm.hostname != "":
-            self.add_error("VM Already Running")
-
-        if self.action.value == "stop" and vm.status == VMStatus.stopped:
-            self.add_error("VM Already Stopped")
-
-
-class VmMigrationSchema(OTPSchema):
-    def __init__(self, data):
-        self.uuid = VmUUIDField(data)
-        self.destination = Field("destination", str, data.get("destination", KeyError))
-
-        self.destination.validation = self.destination_validation
-
-        fields = [self.destination]
-        super().__init__(data=data, fields=fields)
-
-    def destination_validation(self):
-        host_key = self.destination.value
-        host = host_pool.get(host_key)
-        if not host:
-            self.add_error(f"No Such Host ({self.destination.value}) exists")
-        elif host.status != HostStatus.alive:
-            self.add_error("Destination Host is dead")
-
-    def validation(self):
-        vm = vm_pool.get(self.uuid.value)
-        if vm.owner != self.name.value:
-            self.add_error("Invalid User")
-
-        if vm.status != VMStatus.running:
-            self.add_error("Can't migrate non-running VM")
-
-        if vm.hostname == join("/v1/host", self.destination.value):
-            self.add_error("Destination host couldn't be same as Source Host")
+########################## Host Operations ###############################################


 class CreateHostSchema(OTPSchema):
@ -191,3 +141,211 @@ class CreateHostSchema(OTPSchema):
    def validation(self):
        if self.realm.value != "ungleich-admin":
            self.add_error("Invalid Credentials/Insufficient Permission")
+
+
+########################## VM Operations ######################################
+
+
+class CreateVMSchema(OTPSchema):
+    def __init__(self, data):
+        self.parsed_specs = {}
+        # Fields
+        self.specs = Field("specs", dict, data.get("specs", KeyError))
+        self.vm_name = Field("vm_name", str, data.get("vm_name", KeyError))
+        self.image_uuid = Field("image_uuid", str, data.get("image_uuid", KeyError))
+
+        # Validation
+        self.image_uuid.validation = self.image_uuid_validation
+        self.vm_name.validation = self.vm_name_validation
+        self.specs.validation = self.specs_validation
+
+        fields = [self.vm_name, self.image_uuid, self.specs]
+
+        super().__init__(data=data, fields=fields)
+
+    def image_uuid_validation(self):
+        images = client.get_prefix(IMAGE_PREFIX)
+
+        if self.image_uuid.value not in [i.key.split("/")[-1] for i in images]:
+            self.add_error("Image UUID not valid")
+
+    def vm_name_validation(self):
+        if resolve_vm_name(name=self.vm_name.value, owner=self.name.value):
+            self.add_error(
+                'VM with same name "{}" already exists'.format(self.vm_name.value)
+            )
+
+    def specs_validation(self):
+        ALLOWED_BASE = 10
+
+        _cpu = self.specs.value.get('cpu', KeyError) 
+        _ram = self.specs.value.get('ram', KeyError)
+        _os_ssd = self.specs.value.get('os-ssd', KeyError)
+        _hdd = self.specs.value.get('hdd', KeyError)
+
+        if KeyError in [_cpu, _ram, _os_ssd, _hdd]:
+            self.add_error("You must specify CPU, RAM and OS-SSD in your specs")
+            return None
+        try:
+            parsed_ram = bitmath.parse_string_unsafe(_ram)
+            parsed_os_ssd = bitmath.parse_string_unsafe(_os_ssd)
+
+            if parsed_ram.base != ALLOWED_BASE:
+                self.add_error("Your specified RAM is not in correct units")
+            if parsed_os_ssd.base != ALLOWED_BASE:
+                self.add_error("Your specified OS-SSD is not in correct units")
+            
+            if _cpu < 1:
+                self.add_error("CPU must be atleast 1")
+
+            if parsed_ram < bitmath.GB(1):
+                self.add_error("RAM must be atleast 1 GB")
+            
+            if parsed_os_ssd < bitmath.GB(10):
+                self.add_error("OS-SSD must be atleast 10 GB")
+            
+            parsed_hdd = []
+            for hdd in _hdd:
+                _parsed_hdd = bitmath.parse_string_unsafe(hdd)
+                if _parsed_hdd.base != ALLOWED_BASE:
+                    self.add_error("Your specified HDD is not in correct units")
+                    break
+                else:
+                    parsed_hdd.append(str(_parsed_hdd))
+
+        except ValueError:
+            # TODO: Find some good error message
+            self.add_error("Specs are not correct.")
+        else:
+            if self.get_errors():
+                self.specs = {
+                    'cpu': _cpu,
+                    'ram': str(parsed_ram),
+                    'os-ssd': str(parsed_os_ssd),
+                    'hdd': parsed_hdd
+                }
+
+
+class VMStatusSchema(OTPSchema):
+    def __init__(self, data):
+        data["uuid"] = (
+            resolve_vm_name(
+                name=data.get("vm_name", None),
+                owner=(data.get("in_support_of", None) or data.get("name", None)),
+            )
+            or KeyError
+        )
+        self.uuid = VmUUIDField(data)
+
+        fields = [self.uuid]
+
+        super().__init__(data, fields)
+
+    def validation(self):
+        vm = VM_POOL.get(self.uuid.value)
+        if not (
+            vm.value["owner"] == self.name.value or self.realm.value == "ungleich-admin"
+        ):
+            self.add_error("Invalid User")
+
+
+class VmActionSchema(OTPSchema):
+    def __init__(self, data):
+        data["uuid"] = (
+            resolve_vm_name(
+                name=data.get("vm_name", None),
+                owner=(data.get("in_support_of", None) or data.get("name", None)),
+            )
+            or KeyError
+        )
+        self.uuid = VmUUIDField(data)
+        self.action = Field("action", str, data.get("action", KeyError))
+
+        self.action.validation = self.action_validation
+
+        _fields = [self.uuid, self.action]
+
+        super().__init__(data=data, fields=_fields)
+
+    def action_validation(self):
+        allowed_actions = ["start", "stop", "delete"]
+        if self.action.value not in allowed_actions:
+            self.add_error(
+                "Invalid Action. Allowed Actions are {}".format(allowed_actions)
+            )
+
+    def validation(self):
+        vm = VM_POOL.get(self.uuid.value)
+        if not (
+            vm.value["owner"] == self.name.value or self.realm.value == "ungleich-admin"
+        ):
+            self.add_error("Invalid User")
+
+        if (
+            self.action.value == "start"
+            and vm.status == VMStatus.running
+            and vm.hostname != ""
+        ):
+            self.add_error("VM Already Running")
+
+        if self.action.value == "stop":
+            if vm.status == VMStatus.stopped:
+                self.add_error("VM Already Stopped")
+            elif vm.status != VMStatus.running:
+                self.add_error("Cannot stop non-running VM")
+
+
+class VmMigrationSchema(OTPSchema):
+    def __init__(self, data):
+        data["uuid"] = (
+            resolve_vm_name(
+                name=data.get("vm_name", None),
+                owner=(data.get("in_support_of", None) or data.get("name", None)),
+            )
+            or KeyError
+        )
+
+        self.uuid = VmUUIDField(data)
+        self.destination = Field("destination", str, data.get("destination", KeyError))
+
+        self.destination.validation = self.destination_validation
+
+        fields = [self.destination]
+        super().__init__(data=data, fields=fields)
+
+    def destination_validation(self):
+        host_key = self.destination.value
+        host = HOST_POOL.get(host_key)
+        if not host:
+            self.add_error("No Such Host ({}) exists".format(self.destination.value))
+        elif host.status != HostStatus.alive:
+            self.add_error("Destination Host is dead")
+
+    def validation(self):
+        vm = VM_POOL.get(self.uuid.value)
+        if not (
+            vm.value["owner"] == self.name.value or self.realm.value == "ungleich-admin"
+        ):
+            self.add_error("Invalid User")
+
+        if vm.status != VMStatus.running:
+            self.add_error("Can't migrate non-running VM")
+
+        if vm.hostname == os.path.join(HOST_PREFIX, self.destination.value):
+            self.add_error("Destination host couldn't be same as Source Host")
+
+
+class AddSSHSchema(OTPSchema):
+    def __init__(self, data):
+        self.key_name = Field("key_name", str, data.get("key_name", KeyError))
+        self.key = Field("key", str, data.get("key_name", KeyError))
+
+        fields = [self.key_name, self.key]
+        super().__init__(data=data, fields=fields)
+
+class RemoveSSHSchema(OTPSchema):
+    def __init__(self, data):
+        self.key_name = Field("key_name", str, data.get("key_name", KeyError))
+
+        fields = [self.key_name]
+        super().__init__(data=data, fields=fields)
Author	SHA1	Message	Date
meow	f00df143bf	a	2019-10-15 20:27:10 +05:00
Ahmed Bilal Khalid	ef9e9a7967	a	2019-09-26 18:07:17 +05:00
Ahmed Bilal Khalid	3f8edcbc58	a	2019-09-26 17:54:05 +05:00
Ahmed Bilal Khalid	f18dbbe62b	Implemented support for VM operations through VM name, Allow user of realm ungleich-admin to do operation on someone's else VM (for providing support etc), Fix few hidden issues, Refactoring/Formating + Little bit Documenting	2019-09-22 23:51:33 +05:00
Ahmed Bilal Khalid	0f1cf2c7fa	a	2019-09-17 11:51:42 +05:00
Ahmed Bilal Khalid	315fef93fa	a	2019-09-17 11:49:40 +05:00
Ahmed Bilal Khalid	bd43dc8c9d	a	2019-09-17 11:27:27 +05:00
Ahmed Bilal Khalid	7c6038e4df	a	2019-09-16 19:39:21 +05:00
Ahmed Bilal Khalid	463f03a27b	a	2019-09-14 20:39:56 +05:00
Ahmed Bilal Khalid	887e9d72a4	a	2019-09-14 19:43:52 +05:00
Ahmed Bilal Khalid	831a646be1	a	2019-09-13 23:58:43 +05:00
Ahmed Bilal Khalid	5f315ad170	a	2019-09-13 15:21:13 +05:00
Ahmed Bilal Khalid	ec032ed0db	a	2019-09-12 20:55:25 +05:00