def __init__(self, resource, defaul_path=''):
        self.resource = resource
        self.default_path = defaul_path
        if client_utils.check_identity_variables():
            self.identity = client_utils.get_identity_variables()
        else:
            raise ParseException(401
                                 , 'Environmet variables are need: OS_AUTH_URL=127.0.0.23,'
                                   ' OS_PORT=5000, OS_VERSION=v3, OS_TOKEN=948473890234890')

            #self.identity = {'OS_AUTH_URL':'127.0.0.23','OS_PORT': '5000', "OS_VERSION": 'v3','OS_TOKEN':'cb6ec577f8a340f7bf49812aada2cfde'}
        self.os_helper = OpenStackDriver(self.identity['OS_AUTH_URL'],self.identity['OS_TOKEN'])
class ControllerResource(object):
    # todo(jorgesece): one controller per resource or endpoint should be a parameter with flexible path
    resource = None

    def __init__(self, resource, defaul_path=''):
        self.resource = resource
        self.default_path = defaul_path
        if client_utils.check_identity_variables():
            self.identity = client_utils.get_identity_variables()
        else:
            raise ParseException(401
                                 , 'Environmet variables are need: OS_AUTH_URL=127.0.0.23,'
                                   ' OS_PORT=5000, OS_VERSION=v3, OS_TOKEN=948473890234890')

            #self.identity = {'OS_AUTH_URL':'127.0.0.23','OS_PORT': '5000', "OS_VERSION": 'v3','OS_TOKEN':'cb6ec577f8a340f7bf49812aada2cfde'}
        self.os_helper = OpenStackDriver(self.identity['OS_AUTH_URL'],self.identity['OS_TOKEN'])

    def set_resource(self, resource):
        self.resource = resource

    def get_resource(self):
        return self.resource

    def set_path(self, path):
        self.default_path = path

    def index(self, parameters=None):
        """List resources filtered by parameters
        :param parameters: request parameters
        """
        path = '%s/%s' % (self.default_path, self.resource)
        r = self.os_helper.index(path, parameters)
        return r[self.resource]

    def create(self, parameters):
        """Create a resource instance in the cloud
        :param parameters: array of projects (containg their paramemters)
        """
        path = '%s/%s' % (self.default_path, self.resource)
        created = []
        error_creation = []
        for param in parameters:
            if 'name' not in param:
                raise ParseException(400, "Bad attribute definition for OS")
            try:
                result = self.os_helper.create(path, param)
                created.append(result[self.resource[:-1]])
            except Exception as e:
                result = parsers.parse_controller_err(param['name'], e.message)
                error_creation.append(result)
        return created, error_creation

    def show(self, id, parameters=None):
        """Get resource details
        :param id: identificator
        """
        showed = []
        showed_err = []
        try:
            path = '%s/%s' % (self.default_path, self.resource)
            if id:
                path = '%s/%s' % (path, id)
            result = self.os_helper.show(path, parameters)
            if self.resource[:-1] in result:
                showed.append(result[self.resource[:-1]])
            else:
                showed.append(result[self.resource])
        except TypeError:
            result = parsers.parse_controller_err("Undefined", "Bad attribute definition for OS")
            showed_err.append(result)
        except Exception as e:
            result = parsers.parse_controller_err(id, e.message)
            showed_err.append(result)
        return showed, showed_err

    def link(self, id): # fixme(jorgesece): manage it with parameters list
        """Put link resources
        :param id: identificator
        """
        linked = []
        link_err = []
        try:
            path = '%s/%s/%s' % (self.default_path, self.resource, id)
            result = self.os_helper.put(path)
            result = parsers.parse_controller_delete("statisfully linked", id, result)
            linked.append(result)
        except TypeError:
            result = parsers.parse_controller_delete("ERROR", "Undefined", "Bad attribute definition for OS")
            link_err.append(result)
        except Exception as e:
            result = parsers.parse_controller_err(id, e.message)
            link_err.append(result)
        return linked, link_err

    def delete(self, parameters):
        """delete resources which satisfy the parameters
        :param parameters:
        """
        deleted = []
        deleted_err = []
        for param in parameters:
            try:
                path = '%s/%s/%s' % (self.default_path, self.resource, param['id'])
                result = self.os_helper.delete(path)
                result = parsers.parse_controller_delete("statisfully deleted", param['id'], result)
                deleted.append(result)
            except TypeError:
                result = parsers.parse_controller_delete("ERROR", "Undefined", "Bad attribute definition for OS")
                deleted_err.append(result)
            except Exception as e:
                result = parsers.parse_controller_delete("ERROR",param['id'], e.message)
                deleted_err.append(result)
        return deleted, deleted_err

    def custom_query(self, path, custom_resource, parameters=None):
        """List resources filtered by parameters
        :param parameters: request parameters
        """
        r = self.os_helper.index(path, parameters)
        r = r[custom_resource]
        return r