Page History
...
Updating a license in a running instance of Yellowfin is possible with the POST /api/rpc/licence-management/upload-licence end-point (https://developers.yellowfinbi.com/dev/api-docs/current/#operation/uploadLicence ), Upload License.
This particular endpoint uses a form based submission paradigm. A single form body is required named “newLicence” which should contain the license file’s contents.
The following code examples illustrate how to upload a license via the POST /api/rpc/licence-management/upload-licence end-point:
Java | C# | Go | JavaScript | PHP | Python
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
package rest.code.examples;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Random;
import org.apache.hc.client5.http.entity.mime.HttpMultipartMode;
import org.apache.hc.client5.http.entity.mime.MultipartEntityBuilder;
import org.apache.hc.client5.http.fluent.Content;
import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.HttpEntity;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Upload License File via the Yellowfin REST API
*/
public class UploadALicenseFile {
public static void main(String[] args) throws Exception {
System.out.println("Upload License File");
String host = "http://localhost:8080/Yellowfin";
String restUsername = "admin@yellowfin.com.au";
String restPassword = "test";
String fileToImport = "/Downloads/Yellowfin-License.lic";
Path licenseFile = Paths.get(fileToImport);
byte[] fileContents = Files.readAllBytes(licenseFile);
String token = generateToken(host, restUsername, restPassword);
HttpEntity newLicenseFileMulitpartEntity = MultipartEntityBuilder
.create()
.setMode(HttpMultipartMode.LEGACY)
.setCharset(Charset.forName("UTF-8"))
.addBinaryBody("newLicence", fileContents , ContentType.DEFAULT_BINARY, licenseFile.getFileName().toString())
.build();
System.out.println("Upload License Content");
Content uploadLicenseContent = Request.post(host + "/api/rpc/licence-management/upload-licence")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong() + ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", newLicenseFileMulitpartEntity.getContentType())
.addHeader("cache-control", "no-cache")
.body(newLicenseFileMulitpartEntity)
.execute()
.returnContent();
System.out.println("License Upload Complete");
System.out.println(uploadLicenseContent.asString());
}
/*
* This function generates an access token for a user that will grant them access to
* call REST API endpoints.
*/
public static String generateToken(String host, String username, String password) throws IOException {
Content c = Request.post(host + "/api/refresh-tokens")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong())
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString("{ \"userName\": \""+ username + "\",\"password\": \""+ password + "\"}", null)
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement accessToken = jsonObject.getAsJsonObject("_embedded").getAsJsonObject("accessToken").get("securityToken");
if (accessToken!=null) {
System.out.println("Access Token: " + accessToken);
} else {
System.out.println("Token not retrieved successfully");
System.exit(-1);
}
return accessToken.getAsString();
}
} |
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
using System.Net.Http.Headers;
using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace YellowfinAPIExamples
{
public class UploadALicenseFile
{
public static async Task Main(string[] args)
{
Console.WriteLine("Upload License File");
string host = "http://localhost:8080/Yellowfin";
string restUsername = "admin@yellowfin.com.au";
string restPassword = "test";
string fileToImport = "/Downloads/Yellowfin-License.lic";
byte[] fileContents = File.ReadAllBytes(fileToImport);
string token = await GenerateToken(host, restUsername, restPassword);
MultipartFormDataContent multipartContent = new MultipartFormDataContent();
ByteArrayContent fileContent = new ByteArrayContent(fileContents);
fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/octet-stream");
multipartContent.Add(fileContent, "newLicence", Path.GetFileName(fileToImport));
Console.WriteLine("Upload License Content");
using (var httpClient = new HttpClient())
{
long nonce = new Random().NextInt64();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("YELLOWFIN", $"ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={nonce}, token={token}");
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
HttpResponseMessage response = await httpClient.PostAsync(host + "/api/rpc/licence-management/upload-licence", multipartContent);
if (response.IsSuccessStatusCode)
{
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine("License Upload Complete");
Console.WriteLine(responseBody);
}
else
{
Console.WriteLine($"Failed to upload license. Status code: {response.StatusCode}");
}
}
}
public static async Task<string> GenerateToken(string host, string username, string password)
{
using (var client = new HttpClient())
{
long nonce = new Random().NextInt64();
var requestBody = new
{
userName = username,
password = password
};
string jsonRequestBody = JsonConvert.SerializeObject(requestBody);
var request = new HttpRequestMessage(HttpMethod.Post, host + "/api/refresh-tokens");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={nonce}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
request.Content = new StringContent(jsonRequestBody, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
JObject jsonObject = JsonConvert.DeserializeObject<JObject>(responseContent);
string accessToken = jsonObject["_embedded"]["accessToken"]["securityToken"].ToString();
if (!string.IsNullOrEmpty(accessToken))
{
Console.WriteLine("Access Token: " + accessToken);
}
else
{
Console.WriteLine("Token not retrieved successfully");
Environment.Exit(-1);
}
return accessToken;
}
}
}
} |
Code Block | ||||
---|---|---|---|---|
| ||||
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"math/rand"
"mime/multipart"
"net/http"
"os"
"path/filepath"
"time"
)
func main() {
fmt.Println("Upload License File")
host := "http://localhost:8080/Yellowfin"
restUsername := "admin@yellowfin.com.au"
restPassword := "test"
fileToImport := "/Downloads/Yellowfin-License.lic"
filePath := filepath.Clean(fileToImport)
token, err := generateToken(host, restUsername, restPassword)
if err != nil {
fmt.Println("Error generating token:", err)
return
}
file, err := os.Open(filePath)
if err != nil {
fmt.Println("Error opening file:", err)
return
}
defer file.Close()
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("newLicence", filepath.Base(filePath))
if err != nil {
fmt.Println("Error writing to buffer:", err)
return
}
_, err = io.Copy(part, file)
if err != nil {
fmt.Println("Error copying file to buffer:", err)
return
}
err = writer.Close()
if err != nil {
fmt.Println("Error closing writer:", err)
return
}
nonce := rand.Int63()
req, err := http.NewRequest("POST", host+"/api/rpc/licence-management/upload-licence", body)
if err != nil {
fmt.Println("Error creating request:", err)
return
}
req.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), nonce, token))
req.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
req.Header.Set("Content-Type", writer.FormDataContentType())
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
fmt.Println("License Upload Complete")
responseBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
fmt.Println(string(responseBody))
}
func generateToken(host, restUsername, restPassword string) (string, error) {
nonce := rand.Int63()
reqBody := fmt.Sprintf(`{"userName": "%s", "password": "%s"}`, restUsername, restPassword)
req, err := http.NewRequest("POST", host+"/api/refresh-tokens", bytes.NewBufferString(reqBody))
if err != nil {
return "", err
}
req.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d", time.Now().UnixMilli(), nonce))
req.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
var jsonResponse map[string]interface{}
if err := json.Unmarshal(respBody, &jsonResponse); err != nil {
return "", err
}
accessToken, ok := jsonResponse["_embedded"].(map[string]interface{})["accessToken"].(map[string]interface{})["securityToken"].(string)
if !ok {
return "", fmt.Errorf("Token not retrieved successfully")
}
return accessToken, nil
} |
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
const fs = require('fs');
const FormData = require('form-data');
const fetch = require('node-fetch');
async function main() {
const host = "http://localhost:8080/Yellowfin";
const restUsername = "admin@yellowfin.com.au";
const restPassword = "test";
const fileToImport = "/Downloads/Yellowfin-License.lic";
const fileContents = fs.readFileSync(fileToImport);
const fileName = fileToImport.split('/').pop(); // Extracting filename from path
const token = await generateToken(host, restUsername, restPassword);
if (!token) {
console.error("Failed to retrieve access token");
return;
}
console.log("Upload License File");
const formData = new FormData();
formData.append('newLicence', fileContents, { filename: fileName });
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${generateNonce()}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
...formData.getHeaders()
};
try {
const response = await fetch(`${host}/api/rpc/licence-management/upload-licence`, {
method: 'POST',
headers: headers,
body: formData
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.text();
console.log("License Upload Complete");
console.log(responseBody);
} catch (error) {
console.error("Error:", error.message);
}
}
async function generateToken(host, restUsername, restPassword) {
const nonce = generateNonce();
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
const body = JSON.stringify({
userName: restUsername,
password: restPassword
});
try {
const response = await fetch(`${host}/api/refresh-tokens`, {
method: 'POST',
headers: headers,
body: body
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const jsonResponse = await response.json();
const accessToken = jsonResponse._embedded.accessToken.securityToken;
if (accessToken) {
console.log(`Access Token: ${accessToken}`);
} else {
console.log("Token not retrieved");
}
return accessToken;
} catch (error) {
console.error("Error:", error.message);
}
return null;
}
function generateNonce() {
return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
}
main(); |
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
<?php
function main() {
$host = "http://localhost:8080/Yellowfin";
$restUsername = "admin@yellowfin.com.au";
$restPassword = "test";
$fileToImport = "/Downloads/Yellowfin-License.lic";
try {
$token = generateToken($host, $restUsername, $restPassword);
} catch (Exception $e) {
echo "Error generating token: " . $e->getMessage();
return;
}
// Read file contents
try {
$fileContents = file_get_contents($fileToImport);
} catch (Exception $e) {
echo "Error reading file: " . $e->getMessage();
return;
}
$fileName = basename($fileToImport);
// Build multipart form data
$importOptions = json_encode(array(
"option1" => "value1",
"option2" => "value2"
));
$multipartBody = buildMultipartEntity($fileContents, $fileName, $importOptions);
echo "Upload License Content\n";
try {
$response = sendMultipartRequest($host, $token, $multipartBody, "/api/rpc/licence-management/upload-licence");
echo "License Upload Complete\n";
echo $response . "\n";
} catch (Exception $e) {
echo "Error uploading license: " . $e->getMessage();
}
}
function generateToken($host, $restUsername, $restPassword) {
// Generate nonce
$nonce = mt_rand();
// Create request body
$requestBody = json_encode(array(
"userName" => $restUsername,
"password" => $restPassword
));
// Create request headers
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('POST', "$host/api/refresh-tokens", $headers, $requestBody);
$jsonResponse = json_decode($response, true);
// Get access token from response
if (isset($jsonResponse["_embedded"]["accessToken"]["securityToken"])) {
$accessToken = $jsonResponse["_embedded"]["accessToken"]["securityToken"];
echo "Access Token: " . $accessToken;
return $accessToken;
} else {
throw new Exception("Token not retrieved successfully");
}
} catch (Exception $e) {
throw new Exception("Error generating token: " . $e->getMessage());
}
}
function buildMultipartEntity($fileContents, $fileName, $importOptions) {
$boundary = uniqid();
$multipartBody = "--$boundary\r\n";
$multipartBody .= 'Content-Disposition: form-data; name="newLicence"; filename="' . $fileName . "\"\r\n";
$multipartBody .= "Content-Type: application/octet-stream\r\n\r\n";
$multipartBody .= $fileContents . "\r\n";
$multipartBody .= "--$boundary\r\n";
$multipartBody .= 'Content-Disposition: form-data; name="importOptions"' . "\r\n";
$multipartBody .= "Content-Type: application/json\r\n\r\n";
$multipartBody .= $importOptions . "\r\n";
$multipartBody .= "--$boundary--";
return $multipartBody;
}
function sendMultipartRequest($host, $token, $multipartBody, $endpoint) {
$boundary = substr($multipartBody, 2, strpos($multipartBody, "\r\n") - 2);
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . mt_rand() . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: multipart/form-data; boundary=' . $boundary,
'cache-control: no-cache'
);
try {
$response = httpRequest('POST', "$host$endpoint", $headers, $multipartBody);
return $response;
} catch (Exception $e) {
throw new Exception("Error sending multipart request: " . $e->getMessage());
}
}
function httpRequest($method, $url, $headers, $data = null) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
if ($data !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
}
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Error: ' . curl_error($ch));
}
curl_close($ch);
return $response;
}
main();
?> |
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
import json
import random
import time
import os
import requests
def main():
host = "http://localhost:8080/Yellowfin"
rest_username = "admin@yellowfin.com.au"
rest_password = "test"
file_to_import = "/Downloads/Yellowfin-License.lic"
token = generate_token(host, rest_username, rest_password)
# Ensure the file exists
if not os.path.exists(file_to_import):
print(f"Error: File '{file_to_import}' not found.")
return
# Read file contents
with open(file_to_import, 'rb') as file:
file_contents = file.read()
# Prepare headers
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={random.randint(0, 2**63 - 1)}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'cache-control': 'no-cache'
}
# Prepare multipart form data manually
files = {
'newLicence': (file_to_import, file_contents, 'application/octet-stream')
}
try:
response = requests.post(f"{host}/api/rpc/licence-management/upload-licence", headers=headers, files=files)
response.raise_for_status()
print("License Upload Complete")
print(response.text)
except requests.RequestException as e:
print(f"Error uploading license: {e}")
def generate_token(host, rest_username, rest_password):
nonce = random.randint(0, 2 ** 63 - 1)
# Create request body
request_body = json.dumps({
"userName": rest_username,
"password": rest_password
})
# Create request headers
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.post(f"{host}/api/refresh-tokens", headers=headers, data=request_body)
response.raise_for_status()
json_response = response.json()
access_token = json_response["_embedded"]["accessToken"]["securityToken"]
print("Access Token:", access_token)
return access_token
except requests.RequestException as e:
raise Exception("Token not retrieved successfully") from e
if __name__ == "__main__":
main() |
License Auto Provisioning
...
The server can operate on HTTP, HTTPS or SFTP. HTTP and HTTPS support basic authentication. SFTP requires user authentication to connect.
Code Block |
---|
<servlet> |
...
<servlet-name>LicenceAutoProvision</servlet-name> |
...
<servlet-class>com.hof.servlet.LicenceAutoProvision</servlet-class> |
...
<init-param> |
...
<param-name>Enabled</param-name> |
...
<param-value>true</param-value> |
...
</init-param> |
...
<init-param> |
...
<param-name>TaskPeriodInterval</param-name> |
...
<param-value>360</param-value> |
...
</init-param> |
...
<init-param> |
...
<param-name>Protocol</param-name> |
...
<param-value>http</param-value> |
...
<!-- <param-value>https</param-value>--> |
...
<!-- <param-value>sftp</param-value>--> |
...
</init-param> |
...
<init-param> |
...
<param-name>Hostname</param-name> |
...
<param-value>localhost</param-value> |
...
</init-param> |
...
<init-param> |
...
<param-name>Port</param-name> |
...
<param-value>8100</param-value> |
...
</init-param> |
...
<init-param> |
...
<param-name>PathToLicenceFile</param-name> |
...
<param-value>/static/licence.lic</param-value> |
...
</init-param> |
...
<init-param> |
...
<param-name>Username</param-name> |
...
<param-value>demo</param-value> |
...
</init-param> |
...
<init-param> |
...
<param-name>Password</param-name> |
...
<param-value>demo</param-value> |
...
</init-param> |
...
<load-on-startup><!-- can use 9 or greater, as long as its one of the last servlet initialized --></load-on-startup> |
...
</servlet> |
...
|