Skip to content

CIRCLE / libocci

Go to a project
Commit e1a16dd7 by Fukász Rómeó Ervin
Options

made setup.py pass flake8 

seperated the header only lib to delaration and implementation
parent d29bcc7f
Showing with 673 additions and 388 deletions
compute.cpp 0 → 100644
// Copyright 2017 Budapest University of Technology and Economics (BME IK)
//
// This file is part of CIRCLE Cloud.
//
// CIRCLE is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along
// with CIRCLE. If not, see <http://www.gnu.org/licenses/>.
#include <string>
#include "json.hpp"
#include "resource.h"
#include "template.h"
#include "compute.h"
using std::string;
using nlohmann::json;
using namespace OcciClient;
void Compute::parseJsonInstance(json instance) {
Resource::parseJsonInstance(instance);
this->state = getAttributeFromRendering<string>(instance, "occi.compute.state");
this->stateMessage = getAttributeFromRendering<string>(instance, "occi.compute.state.message");
this->memory = getAttributeFromRendering<double>(instance, "occi.compute.memory");
this->cpuShare = getAttributeFromRendering<int>(instance, "occi.compute.share");
this->cores = getAttributeFromRendering<int>(instance, "occi.compute.cores");
this->hostname = getAttributeFromRendering<string>(instance, "occi.compute.hostname");
this->architecture = getAttributeFromRendering<string>(instance, "occi.compute.architecture");
this->credentialProtocol = getAttributeFromRendering<string>(instance, "org.circlecloud.occi.credentials.protocol");
this->credentialPort = getAttributeFromRendering<int>(instance, "org.circlecloud.occi.credentials.port");
this->credentialHost = getAttributeFromRendering<string>(instance, "org.circlecloud.occi.credentials.host");
this->credentialUsername = getAttributeFromRendering<string>(instance, "org.circlecloud.occi.credentials.username");
this->credentialPassword = getAttributeFromRendering<string>(instance, "org.circlecloud.occi.credentials.password");
this->credentialCommand = getAttributeFromRendering<string>(instance, "org.circlecloud.occi.credentials.command");
this->rendering = instance;
}
Compute::Compute(OcciSession* session, json instance) : Resource(session, "compute", instance) {
parseJsonInstance(instance);
}
void Compute::invokeAction(json actionData) {
auto inst = Resource::invokeAction(actionData);
parseJsonInstance(inst);
}
public:
static shared_ptr<Compute> Compute::getComputeInstance(OcciSession* session, string id) {
auto uri = "compute/" + id + "/";
auto instance = session->get(uri);
return make_shared<Compute>(Compute(session, instance));
}
static shared_ptr<Compute> Compute::createComputeInstance(OcciSession* session, Template t) {
auto uri = "compute/1/";
json data = json::parse("{\"mixins\": [\"" + t + "\"]}");
auto instance = session->put(uri, data);
return make_shared<Compute>(Compute(session, instance));
}
string Compute::getState(){
return this->state;
}
string Compute::getStateMessage(){
return this->stateMessage;
}
double Compute::getMemory(){
return this->memory;
}
int Compute::getCpuShare(){
return this->cpuShare;
}
int Compute::getCores(){
return this->cores;
}
string Compute::getHostname(){
return this->hostname;
}
string Compute::getArchitecture(){
return this->architecture;
}
string Compute::getCredentialProtocol(){
return this->credentialProtocol;
}
int Compute::getCredentialPort(){
return this->credentialPort;
}
string Compute::getCredentialHost(){
return this->credentialHost;
}
string Compute::getCredentialPassword(){
return this->credentialPassword;
}
string Compute::getCredentialUsername(){
return this->credentialUsername;
}
string Compute::getCredentialCommand(){
return this->credentialCommand;
}
void Compute::start() {
json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#start"}
};
invokeAction(actionData);
}
void Compute::wakeup() {
start();
}
void Compute::sleep() {
json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#suspend"},
{"attributes", {
{"method", "suspend"}
}}
};
invokeAction(actionData);
}
void Compute::reboot() {
json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#restart"},
{"attributes", {
{"method", "warm"}
}}
};
invokeAction(actionData);
}
void Compute::reset() {
json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#restart"},
{"attributes", {
{"method", "cold"}
}}
};
invokeAction(actionData);
}
void Compute::shutdown() {
json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#stop"},
{"attributes", {
{"method", "acpioff"}
}}
};
invokeAction(actionData);
}
void Compute::shutoff() {
json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#stop"},
{"attributes", {
{"method", "poweroff"}
}}
};
invokeAction(actionData);
}
compute.h
......@@ -27,6 +27,7 @@
namespace OcciClient {
class Compute : public Resource {
private:
std::string state;
......@@ -44,161 +45,57 @@ namespace OcciClient {
std::string credentialUsername;
std::string credentialCommand;
void parseJsonInstance(nlohmann::json instance) {
Resource::parseJsonInstance(instance);
this->state = getAttributeFromRendering<std::string>(instance, "occi.compute.state");
this->stateMessage = getAttributeFromRendering<std::string>(instance, "occi.compute.state.message");
this->memory = getAttributeFromRendering<double>(instance, "occi.compute.memory");
this->cpuShare = getAttributeFromRendering<int>(instance, "occi.compute.share");
this->cores = getAttributeFromRendering<int>(instance, "occi.compute.cores");
this->hostname = getAttributeFromRendering<std::string>(instance, "occi.compute.hostname");
this->architecture = getAttributeFromRendering<std::string>(instance, "occi.compute.architecture");
this->credentialProtocol = getAttributeFromRendering<std::string>(instance, "org.circlecloud.occi.credentials.protocol");
this->credentialPort = getAttributeFromRendering<int>(instance, "org.circlecloud.occi.credentials.port");
this->credentialHost = getAttributeFromRendering<std::string>(instance, "org.circlecloud.occi.credentials.host");
this->credentialUsername = getAttributeFromRendering<std::string>(instance, "org.circlecloud.occi.credentials.username");
this->credentialPassword = getAttributeFromRendering<std::string>(instance, "org.circlecloud.occi.credentials.password");
this->credentialCommand = getAttributeFromRendering<std::string>(instance, "org.circlecloud.occi.credentials.command");
this->rendering = instance;
}
Compute(OcciSession* session, nlohmann::json instance)
: Resource(session, "compute", instance) {
parseJsonInstance(instance);
}
void invokeAction(nlohmann::json actionData) {
auto inst = Resource::invokeAction(actionData);
parseJsonInstance(inst);
}
void parseJsonInstance(nlohmann::json instance);
Compute(OcciSession* session, nlohmann::json instance);
void invokeAction(nlohmann::json actionData);
public:
static std::shared_ptr<Compute> getComputeInstance(OcciSession* session, std::string id) {
auto uri = "compute/" + id + "/";
auto instance = session->get(uri);
return std::make_shared<Compute>(Compute(session, instance));
}
static std::shared_ptr<Compute> createComputeInstance(OcciSession* session, Template t) {
auto uri = "compute/1/";
nlohmann::json data = nlohmann::json::parse("{\"mixins\": [\"" + t + "\"]}");
auto instance = session->put(uri, data);
return std::make_shared<Compute>(Compute(session, instance));
}
std::string getState(){
return this->state;
}
std::string getStateMessage(){
return this->stateMessage;
}
double getMemory(){
return this->memory;
}
int getCpuShare(){
return this->cpuShare;
}
int getCores(){
return this->cores;
}
std::string getHostname(){
return this->hostname;
}
std::string getArchitecture(){
return this->architecture;
}
std::string getCredentialProtocol(){
return this->credentialProtocol;
}
int getCredentialPort(){
return this->credentialPort;
}
std::string getCredentialHost(){
return this->credentialHost;
}
std::string getCredentialPassword(){
return this->credentialPassword;
}
std::string getCredentialUsername(){
return this->credentialUsername;
}
std::string getCredentialCommand(){
return this->credentialCommand;
}
void start() {
nlohmann::json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#start"}
};
invokeAction(actionData);
}
void wakeup() {
start();
}
void sleep() {
nlohmann::json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#suspend"},
{"attributes", {
{"method", "suspend"}
}}
};
invokeAction(actionData);
}
void reboot() {
nlohmann::json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#restart"},
{"attributes", {
{"method", "warm"}
}}
};
invokeAction(actionData);
}
void reset() {
nlohmann::json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#restart"},
{"attributes", {
{"method", "cold"}
}}
};
invokeAction(actionData);
}
void shutdown() {
nlohmann::json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#stop"},
{"attributes", {
{"method", "acpioff"}
}}
};
invokeAction(actionData);
}
void shutoff() {
nlohmann::json actionData = {
{"action", "http://schemas.ogf.org/occi/infrastructure/compute/action#stop"},
{"attributes", {
{"method", "poweroff"}
}}
};
invokeAction(actionData);
}
static std::shared_ptr<Compute> getComputeInstance(OcciSession* session, std::string id);
static std::shared_ptr<Compute> createComputeInstance(OcciSession* session, Template t);
std::string getState();
std::string getStateMessage();
double getMemory();
int getCpuShare();
int getCores();
std::string getHostname();
std::string getArchitecture();
std::string getCredentialProtocol();
int getCredentialPort();
std::string getCredentialHost();
std::string getCredentialPassword();
std::string getCredentialUsername();
std::string getCredentialCommand();
void start();
void wakeup();
void sleep();
void reboot();
void reset();
void shutdown();
void shutoff();
};
}
......
network.cpp 0 → 100644
// Copyright 2017 Budapest University of Technology and Economics (BME IK)
//
// This file is part of CIRCLE Cloud.
//
// CIRCLE is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along
// with CIRCLE. If not, see <http://www.gnu.org/licenses/>.
#include <string>
#include "json.hpp"
#include "resource.h"
#include "network.h"
using std::string;
using nlohmann::json;
using namespace OcciClient;
void Network::parseJsonInstance(json instance) {
Resource::parseJsonInstance(instance);
this->state = getAttributeFromRendering<string>(instance, "occi.network.state");
this->stateMessage = getAttributeFromRendering<string>(instance, "occi.network.state.message");
this->vlan = getAttributeFromRendering<int>(instance, "occi.network.vlan");
this->address = getAttributeFromRendering<string>(instance, "occi.network.address");
this->gateway = getAttributeFromRendering<string>(instance, "occi.network.gateway");
this->allocation = getAttributeFromRendering<string>(instance, "occi.network.allocation");
this->rendering = instance;
}
Network::Network(OcciSession* session, json instance)
: Resource(session, "network", instance) {
parseJsonInstance(instance);
}
void Network::invokeAction(json actionData) {
auto inst = Resource::invokeAction(actionData);
parseJsonInstance(inst);
}
shared_ptr<Network> Network::getNetworkInstance(OcciSession* session, string id) {
auto uri = "network/" + id + "/";
auto instance = session->get(uri);
return make_shared<Network>(Network(session, instance));
}
string Network::getState(){
return this->state;
}
string Network::getStateMessage(){
return this->stateMessage;
}
int Network::getVlan(){
return this->vlan;
}
string Network::getAddress(){
return this->address;
}
string Network::getGateway(){
return this->gateway;
}
string Network::getAllocation(){
return this->allocation;
}
network.h
......@@ -36,58 +36,27 @@ namespace OcciClient {
std::string gateway;
std::string allocation;
void parseJsonInstance(nlohmann::json instance) {
Resource::parseJsonInstance(instance);
this->state = getAttributeFromRendering<std::string>(instance, "occi.network.state");
this->stateMessage = getAttributeFromRendering<std::string>(instance, "occi.network.state.message");
this->vlan = getAttributeFromRendering<int>(instance, "occi.network.vlan");
this->address = getAttributeFromRendering<std::string>(instance, "occi.network.address");
this->gateway = getAttributeFromRendering<std::string>(instance, "occi.network.gateway");
this->allocation = getAttributeFromRendering<std::string>(instance, "occi.network.allocation");
this->rendering = instance;
}
Network(OcciSession* session, nlohmann::json instance)
: Resource(session, "network", instance) {
parseJsonInstance(instance);
}
void invokeAction(nlohmann::json actionData) {
auto inst = Resource::invokeAction(actionData);
parseJsonInstance(inst);
}
void parseJsonInstance(nlohmann::json instance);
Network(OcciSession* session, nlohmann::json instance);
void invokeAction(nlohmann::json actionData);
public:
static std::shared_ptr<Network> getNetworkInstance(OcciSession* session, std::string id) {
auto uri = "network/" + id + "/";
auto instance = session->get(uri);
return std::make_shared<Network>(Network(session, instance));
}
static std::shared_ptr<Network> getNetworkInstance(OcciSession* session, std::string id);
std::string getState(){
return this->state;
}
std::string getState();
std::string getStateMessage(){
return this->stateMessage;
}
std::string getStateMessage();
int getVlan(){
return this->vlan;
}
int getVlan();
std::string getAddress(){
return this->address;
}
std::string getAddress();
std::string getGateway(){
return this->gateway;
}
std::string getGateway();
std::string getAllocation(){
return this->allocation;
}
std::string getAllocation();
};
}
......
occilib.cpp deleted 100644 → 0
#include "occilib.h"
occisession.cpp 0 → 100644
// Copyright 2017 Budapest University of Technology and Economics (BME IK)
//
// This file is part of CIRCLE Cloud.
//
// CIRCLE is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along
// with CIRCLE. If not, see <http://www.gnu.org/licenses/>.
#include <string>
#include <exception>
#include <stdexcept>
#include "restclient-cpp/connection.h"
#include "restclient-cpp/restclient.h"
#include "json.hpp"
#include "occisession.h"
using std::string;
using nlohmann::json;
using namespace OcciClient;
void OcciSession::setCsrfTokenHeader(){
auto resp = this->connection->getLastResponse();
string csrftoken;
try {
csrftoken = resp.cookies.at("csrftoken");
}
catch (const std::out_of_range& e) {
return;
}
this->connection->AppendHeader("X-CSRFToken", csrftoken);
}
OcciSession::OcciSession(const char* url, bool insecure, bool csrf){
RestClient::init();
this->connection = new RestClient::Connection(url);
if (insecure) {
this->connection->SetHostVerify(false);
this->connection->SetPeerVerify(false);
}
this->csrftokenRequired = csrf;
RestClient::HeaderFields headers;
headers["Accept"] = "application/json";
headers["Content-type"] = "application/json";
headers["Referer"] = url;
this->connection->SetHeaders(headers);
}
OcciSession::~OcciSession(){
RestClient::disable();
}
json OcciSession::doRequest(string uri, RequestType type, json body){
RestClient::Response r;
if (this->csrftokenRequired)
this->setCsrfTokenHeader();
if (type == RequestType::Post)
r = connection->post(uri, body.dump());
else if (type == RequestType::Put)
r = connection->put(uri, body.dump());
else if (type == RequestType::Delete)
r = connection->del(uri);
else
r = connection->get(uri);
json result;
try {
result = json::parse(r.body);
}
catch (std::invalid_argument& e) {
result = "{}"_json;
throw std::domain_error("Didn't get a json response from the OCCI server.");
}
try {
throw std::logic_error(result["error"].get<string>());
}
catch (std::domain_error e) {
return result;
}
}
json OcciSession::get(string uri) {
return doRequest(uri, RequestType::Get);
}
json OcciSession::post(string uri, json body) {
return doRequest(uri, RequestType::Post, body);
}
json OcciSession::put(string uri, json body) {
return doRequest(uri, RequestType::Put, body);
}
json OcciSession::del(string uri) {
return doRequest(uri, RequestType::Delete);
}
void OcciSession::circleOcciLogin(string username, string password){
get("login/");
string body = "{\"username\": \"" + username + "\", \"password\": \"" + password + "\"}";
post("login/", json::parse(body));
}
json OcciSession::queryInterface(){
return get("-/");
}
occisession.h
......@@ -20,119 +20,46 @@
#define OCCILIB_SESSION_H_
#include <string>
#include <exception>
#include <stdexcept>
#include "restclient-cpp/connection.h"
#include "restclient-cpp/restclient.h"
#include "json.hpp"
namespace OcciClient {
using std::string;
enum class RequestType{Get, Post, Delete, Put};
class OcciSession {
private:
RestClient::Connection* connection = nullptr;
bool csrftokenRequired = false;
string csrfuri;
void setCsrfTokenHeader(){
auto resp = this->connection->getLastResponse();
string csrftoken;
try {
csrftoken = resp.cookies.at("csrftoken");
}
catch (const std::out_of_range& e) {
return;
}
this->connection->AppendHeader("X-CSRFToken", csrftoken);
}
std::string csrfuri;
void setCsrfTokenHeader();
public:
OcciSession(const char* url, bool insecure = false, bool csrf = false){
RestClient::init();
this->connection = new RestClient::Connection(url);
if (insecure) {
this->connection->SetHostVerify(false);
this->connection->SetPeerVerify(false);
}
this->csrftokenRequired = csrf;
RestClient::HeaderFields headers;
headers["Accept"] = "application/json";
headers["Content-type"] = "application/json";
headers["Referer"] = url;
this->connection->SetHeaders(headers);
}
~OcciSession(){
RestClient::disable();
}
nlohmann::json doRequest(string uri, RequestType type, nlohmann::json body = nullptr){
RestClient::Response r;
if (this->csrftokenRequired)
this->setCsrfTokenHeader();
if (type == RequestType::Post)
r = connection->post(uri, body.dump());
else if (type == RequestType::Put)
r = connection->put(uri, body.dump());
else if (type == RequestType::Delete)
r = connection->del(uri);
else
r = connection->get(uri);
nlohmann::json result;
try {
result = nlohmann::json::parse(r.body);
}
catch (std::invalid_argument& e) {
result = "{}"_json;
throw std::domain_error("Didn't get a nlohmann::json response from the OCCI server.");
}
try {
throw std::logic_error(result["error"].get<string>());
}
catch (std::domain_error e) {
return result;
}
}
nlohmann::json get(string uri) {
return doRequest(uri, RequestType::Get);
}
nlohmann::json post(string uri, nlohmann::json body = nullptr) {
return doRequest(uri, RequestType::Post, body);
}
nlohmann::json put(string uri, nlohmann::json body = nullptr) {
return doRequest(uri, RequestType::Put, body);
}
nlohmann::json del(string uri) {
return doRequest(uri, RequestType::Delete);
}
void circleOcciLogin(string username, string password){
get("login/");
string body = "{\"username\": \"" + username + "\", \"password\": \"" + password + "\"}";
post("login/", nlohmann::json::parse(body));
}
nlohmann::json queryInterface(){
return get("-/");
}
OcciSession(const char* url, bool insecure = false, bool csrf = false);
};
~OcciSession();
nlohmann::json doRequest(std::string uri, RequestType type, nlohmann::json body = nullptr);
nlohmann::json get(std::string uri);
nlohmann::json post(std::string uri, nlohmann::json body = nullptr);
nlohmann::json put(std::string uri, nlohmann::json body = nullptr);
nlohmann::json del(std::string uri);
void circleOcciLogin(std::string username, std::string password);
nlohmann::json queryInterface();
};
}
#endif // OCCILIB_SESSION_H_
resource.cpp 0 → 100644
// Copyright 2017 Budapest University of Technology and Economics (BME IK)
//
// This file is part of CIRCLE Cloud.
//
// CIRCLE is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along
// with CIRCLE. If not, see <http://www.gnu.org/licenses/>.
#include <string>
#include "json.hpp"
#include "occisession.h"
#include "resource.h"
using std::string;
using nlohmann::json;
using namespace OcciClient;
void Resource::parseJsonInstance(json instance) {
this->id = getID(instance);
if (instance.find("title") != instance.end()) {
this->title = instance["title"].get<string>();
}
this->rendering = instance;
}
Resource::Resource(OcciSession* session, string kind, json instance) {
this->session = session;
this->kind = kind;
parseJsonInstance(instance);
}
string Resource::getID(json& rendering) {
try {
return rendering["id"];
}
catch (std::domain_error) {
return "";
}
}
template <typename T> T Resource::getAttributeFromRendering(json& rendering, const string which, const T defaultValue) {
try {
return rendering["attributes"][which].get<T>();
}
catch (std::exception e){
return defaultValue;
}
}
string Resource::getId(){
return this->id;
}
string Resource::getTitle(){
return this->title;
}
json Resource::invokeAction(OcciSession* session, string kind, string id, json actionData) {
auto uri = kind + "/" + id + "/";
return session->post(uri, actionData);
}
json Resource::invokeAction(json actionData){
return invokeAction(this->session, this->kind, this->id, actionData);
}
json Resource::getRendering(){
return this->rendering;
}
void Resource::destroyInstance() {
auto uri = this->kind + "/" + this->id + "/";
session->del(uri);
}
resource.h
......@@ -37,68 +37,28 @@ namespace OcciClient{
nlohmann::json rendering;
string kind;
void parseJsonInstance(nlohmann::json instance) {
this->id = getID(instance);
if (instance.find("title") != instance.end()) {
this->title = instance["title"].get<string>();
}
this->rendering = instance;
}
Resource(OcciSession* session, string kind, nlohmann::json instance) {
this->session = session;
this->kind = kind;
parseJsonInstance(instance);
}
string getID(nlohmann::json& rendering) {
try {
return rendering["id"];
}
catch (std::domain_error) {
return "";
}
}
template <typename T> T getAttributeFromRendering(nlohmann::json& rendering, const string which, const T defaultValue = T()) {
try {
return rendering["attributes"][which].get<T>();
}
catch (std::exception e){
return defaultValue;
}
}
void parseJsonInstance(nlohmann::json instance);
public:
Resource(OcciSession* session, string kind, nlohmann::json instance);
string getId(){
return this->id;
}
string getID(nlohmann::json& rendering);
string getTitle(){
return this->title;
}
template <typename T> T getAttributeFromRendering(nlohmann::json& rendering, const string which, const T defaultValue = T());
static nlohmann::json invokeAction(OcciSession* session, string kind, string id, nlohmann::json actionData) {
auto uri = kind + "/" + id + "/";
return session->post(uri, actionData);
}
public:
nlohmann::json invokeAction(nlohmann::json actionData){
return invokeAction(this->session, this->kind, this->id, actionData);
}
string getId();
nlohmann::json getRendering(){
return this->rendering;
}
string getTitle();
void destroyInstance() {
auto uri = this->kind + "/" + this->id + "/";
session->del(uri);
}
static nlohmann::json invokeAction(OcciSession* session, string kind, string id, nlohmann::json actionData);
};
nlohmann::json invokeAction(nlohmann::json actionData);
nlohmann::json getRendering();
void destroyInstance();
};
}
#endif // OCCILIB_RESOURCE_H_
setup.py
......@@ -6,10 +6,9 @@ https://github.com/pypa/sampleproject
"""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages, Extension
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
from subprocess import check_call
import sys
_occi = Extension('_occi',
......@@ -19,9 +18,11 @@ _occi = Extension('_occi',
swig_opts=['-c++'],
extra_compile_args=['-std=c++11', '-Ofast'],
libraries=['restclient-cpp', 'curl']
)
)
class Build(build_ext):
def run(self):
check_call(['make', 'deps'])
build_ext.run(self)
......
storage.cpp 0 → 100644
// Copyright 2017 Budapest University of Technology and Economics (BME IK)
//
// This file is part of CIRCLE Cloud.
//
// CIRCLE is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along
// with CIRCLE. If not, see <http://www.gnu.org/licenses/>.
#include <string>
#include "json.hpp"
#include "resource.h"
#include "storage.h"
using std::string;
using nlohmann::json;
using namespace OcciClient;
void Storage::parseJsonInstance(json instance) {
Resource::parseJsonInstance(instance);
this->state = getAttributeFromRendering<string>(instance, "occi.storage.state");
this->stateMessage = getAttributeFromRendering<string>(instance, "occi.storage.state.message");
this->size = getAttributeFromRendering<double>(instance, "occi.storage.size");
this->rendering = instance;
}
Storage::Storage(OcciSession* session, json instance)
: Resource(session, "storage", instance) {
parseJsonInstance(instance);
}
void Storage::invokeAction(json actionData) {
auto inst = Resource::invokeAction(actionData);
parseJsonInstance(inst);
}
shared_ptr<Storage> Storage::getStorageInstance(OcciSession* session, string id) {
auto uri = "storage/" + id + "/";
auto instance = session->get(uri);
return make_shared<Storage>(Storage(session, instance));
}
string Storage::getState(){
return this->state;
}
string Storage::getStateMessage(){
return this->stateMessage;
}
double Storage::getSize(){
return this->size;
}
storage.h
......@@ -33,44 +33,21 @@ namespace OcciClient {
std::string state;
std::string stateMessage;
void parseJsonInstance(nlohmann::json instance) {
Resource::parseJsonInstance(instance);
this->state = getAttributeFromRendering<std::string>(instance, "occi.storage.state");
this->stateMessage = getAttributeFromRendering<std::string>(instance, "occi.storage.state.message");
this->size = getAttributeFromRendering<double>(instance, "occi.storage.size");
this->rendering = instance;
}
Storage(OcciSession* session, nlohmann::json instance)
: Resource(session, "storage", instance) {
parseJsonInstance(instance);
}
void invokeAction(nlohmann::json actionData) {
auto inst = Resource::invokeAction(actionData);
parseJsonInstance(inst);
}
void parseJsonInstance(nlohmann::json instance);
public:
Storage(OcciSession* session, nlohmann::json instance);
void invokeAction(nlohmann::json actionData);
static std::shared_ptr<Storage> getStorageInstance(OcciSession* session, std::string id) {
auto uri = "storage/" + id + "/";
auto instance = session->get(uri);
return std::make_shared<Storage>(Storage(session, instance));
}
public:
std::string getState(){
return this->state;
}
static std::shared_ptr<Storage> getStorageInstance(OcciSession* session, std::string id);
std::string getStateMessage(){
return this->stateMessage;
}
std::string getState();
double getSize(){
return this->size;
}
std::string getStateMessage();
double getSize();
};
}
......
template.cpp 0 → 100644
// Copyright 2017 Budapest University of Technology and Economics (BME IK)
//
// This file is part of CIRCLE Cloud.
//
// CIRCLE is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along
// with CIRCLE. If not, see <http://www.gnu.org/licenses/>.
#include <string>
#include <vector>
#include "occisession.h"
#include "json.hpp"
using nlohmann::json;
using std::string;
using std::vector;
using namespace OcciClient;
vector<Template> getTemplates(OcciSession* session){
json mixins = session->queryInterface()["mixins"];
auto result = std::vector<Template>();
for (auto& mixin : mixins) {
if (mixin["depends"] == "http://schemas.ogf.org/occi/infrastructure#os_tpl") {
result.push_back(mixin["scheme"].get<string>() + mixin["term"].get<string>());
}
}
return result;
}
template.h
......@@ -23,23 +23,13 @@
#include <vector>
#include "occisession.h"
#include "json.hpp"
typedef std::string Template;
namespace OcciClient{
std::vector<Template> getTemplates(OcciSession* session){
nlohmann::json mixins = session->queryInterface()["mixins"];
auto result = std::vector<Template>();
for (auto& mixin : mixins) {
if (mixin["depends"] == "http://schemas.ogf.org/occi/infrastructure#os_tpl") {
result.push_back(mixin["scheme"].get<string>() + mixin["term"].get<string>());
}
}
return result;
}
namespace OcciClient{
std::vector<Template> getTemplates(OcciSession* session);
}
#endif // OCCILIB_TEMPLATE_H
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment