Statistics
| Branch: | Revision:

root / snfOCCI / APIserver.py @ 77182fb8

History | View | Annotate | Download (4 kB)

1
#!/usr/bin/env python
2

    
3
from snfOCCI.registry import snfRegistry
4
from snfOCCI.compute import ComputeBackend
5
from snfOCCI.config import SERVER_CONFIG
6

    
7
from kamaki.clients.compute import ComputeClient
8
from kamaki.clients.cyclades import CycladesClient
9
from kamaki.config  import Config
10

    
11
from occi.core_model import Mixin, Resource
12
from occi.backend import MixinBackend
13
from occi.extensions.infrastructure import COMPUTE, START, STOP, SUSPEND, RESTART, RESOURCE_TEMPLATE, OS_TEMPLATE
14
from occi.wsgi import Application
15

    
16
from wsgiref.simple_server import make_server
17
from wsgiref.validate import validator
18

    
19

    
20

    
21

    
22
class MyAPP(Application):
23
    '''
24
    An OCCI WSGI application.
25
    '''
26

    
27
    def refresh_images(self, snf, client):
28

    
29
        images = snf.list_images()
30
        for image in images:
31
            IMAGE_ATTRIBUTES = {'occi.core.id': str(image['id'])}
32
            IMAGE = Mixin("http://schemas.ogf.org/occi/infrastructure#", str(image['name']), [OS_TEMPLATE], attributes = IMAGE_ATTRIBUTES)
33
            self.register_backend(IMAGE, MixinBackend())
34

    
35
    def refresh_flavors(self, snf, client):
36
        
37
        flavors = snf.list_flavors()
38
        for flavor in flavors:
39
            details = snf.get_flavor_details(flavor['id'])
40
            FLAVOR_ATTRIBUTES = {'occi.core.id': flavor['id'],
41
                                 'occi.compute.cores': details['cpu'],
42
                                 'occi.compute.memory': details['ram'],
43
                                 'occi.storage.size': details['disk'],
44
                                 }
45
            FLAVOR = Mixin("http://schemas.ogf.org/occi/infrastructure#", str(flavor['name']), [RESOURCE_TEMPLATE], attributes = FLAVOR_ATTRIBUTES)
46
            self.register_backend(FLAVOR, MixinBackend())
47

    
48

    
49
    def refresh_compute_instances(self, snf):
50
        
51
        servers = snf.list_servers()
52
        snf_keys = []
53
        for server in servers:
54
            snf_keys.append(str(server['id']))
55

    
56
        resources = self.registry.resources
57
        occi_keys = resources.keys()
58
        
59
        diff = [x for x in snf_keys if '/compute/'+x not in occi_keys]
60

    
61
        for key in diff:
62

    
63
            details = snf.get_server_details(int(key))
64
            flavor = snf.get_flavor_details(details['flavorRef'])
65

    
66
            resource = Resource(key, COMPUTE, [])
67

    
68
            resource.actions = [START]
69
            resource.attribute = {}
70
            resource.attributes['occi.core.id'] = key
71
            resource.attributes['occi.compute.state'] = 'inactive'
72
            resource.attributes['occi.compute.architecture'] = SERVER_CONFIG['compute_arch']
73
            resource.attributes['occi.compute.cores'] = flavor['cpu']
74
            resource.attributes['occi.compute.memory'] = flavor['ram']
75
            resource.attributes['occi.compute.hostname'] = SERVER_CONFIG['hostname'] % {'id':int(key)}
76
  
77
            self.registry.add_resource(key, resource, None)
78

    
79
    def __call__(self, environ, response):
80

    
81
        conf = Config()
82
        conf.set('compute_token',environ['HTTP_AUTH_TOKEN'])
83
        compClient = ComputeClient(conf)
84
        cyclClient = CycladesClient(conf)
85

    
86
        #Up-to-date flavors and images
87
        self.refresh_compute_instances(compClient)
88
        self.refresh_images(compClient, cyclClient)
89
        self.refresh_flavors(compClient, cyclClient)
90

    
91
        # token will be represented in self.extras
92
        return self._call_occi(environ, response, security = None, token = environ['HTTP_AUTH_TOKEN'], snf = compClient, client = cyclClient)
93

    
94

    
95
def main():
96

    
97
    APP = MyAPP(registry = snfRegistry())
98
    COMPUTE_BACKEND = ComputeBackend()
99

    
100
    APP.register_backend(COMPUTE, COMPUTE_BACKEND)
101
    APP.register_backend(START, COMPUTE_BACKEND)
102
    APP.register_backend(STOP, COMPUTE_BACKEND)
103
    APP.register_backend(RESTART, COMPUTE_BACKEND)
104
    APP.register_backend(SUSPEND, COMPUTE_BACKEND)
105
    APP.register_backend(RESOURCE_TEMPLATE, MixinBackend())
106
    APP.register_backend(OS_TEMPLATE, MixinBackend())
107
 
108
    VALIDATOR_APP = validator(APP)
109
    HTTPD = make_server('', SERVER_CONFIG['port'], VALIDATOR_APP)
110
    HTTPD.serve_forever()
111