release

AssemblyScript

export enum AppState {
  Stopped = 0,
  Running = 1,
  Crashed = 2
}

export enum ReleaseError {
  Ok = 0,
  NotFound = 1,
  DownloadFailed = 2,
  FileError = 3,
  MemoryError = 4,
  AlreadyRunning = 5,
  AlreadyStopped = 6,
  InvalidWasm = 7
}


// @ts-ignore
@external("release", "list_releases")
export declare function listReleases(): undefined;


// @ts-ignore
@external("release", "get_release_info")
export declare function getReleaseInfo(releaseId: u32): undefined;


// @ts-ignore
@external("release", "download_release")
export declare function downloadRelease(releaseId: u32): ReleaseError;


// @ts-ignore
@external("release", "delete_release")
export declare function deleteRelease(releaseId: u32): ReleaseError;


// @ts-ignore
@external("release", "write_live_release")
export declare function writeLiveRelease(buffer: undefined): ReleaseError;


// @ts-ignore
@external("release", "load_application")
export declare function loadApplication(releaseId: u32): ReleaseError;


// @ts-ignore
@external("release", "stop_application")
export declare function stopApplication(): ReleaseError;


// @ts-ignore
@external("release", "get_application_state")
export declare function getApplicationState(): AppState;


// @ts-ignore
@external("release", "get_current_release_id")
export declare function getCurrentReleaseId(): u32;


// @ts-ignore
@external("release", "get_storage_total")
export declare function getStorageTotal(): u32;


// @ts-ignore
@external("release", "get_storage_used")
export declare function getStorageUsed(): u32;


// @ts-ignore
@external("release", "clean_old_releases")
export declare function cleanOldReleases(keepCount: u32): ReleaseError;

Zig

pub const AppState = enum(u32) {
  stopped = 0,
  running = 1,
  crashed = 2
};

pub const ReleaseError = enum(u32) {
  ok = 0,
  notFound = 1,
  downloadFailed = 2,
  fileError = 3,
  memoryError = 4,
  alreadyRunning = 5,
  alreadyStopped = 6,
  invalidWasm = 7
};


pub extern "release" fn list_releases() undefined;

pub extern "release" fn get_release_info(release_id: u32) undefined;

pub extern "release" fn download_release(release_id: u32) ReleaseError;

pub extern "release" fn delete_release(release_id: u32) ReleaseError;

pub extern "release" fn write_live_release(buffer: undefined) ReleaseError;

pub extern "release" fn load_application(release_id: u32) ReleaseError;

pub extern "release" fn stop_application() ReleaseError;

pub extern "release" fn get_application_state() AppState;

pub extern "release" fn get_current_release_id() u32;

pub extern "release" fn get_storage_total() u32;

pub extern "release" fn get_storage_used() u32;

pub extern "release" fn clean_old_releases(keep_count: u32) ReleaseError;

Rust

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum AppState {
  Stopped = 0,
  Running = 1,
  Crashed = 2
}

#[derive(Debug, Clone, Copy)]
#[repr(u32)]
pub enum ReleaseError {
  Ok = 0,
  NotFound = 1,
  DownloadFailed = 2,
  FileError = 3,
  MemoryError = 4,
  AlreadyRunning = 5,
  AlreadyStopped = 6,
  InvalidWasm = 7
}

#[link(wasm_import_module = "release")]
extern "C" { 
  #[link_name = "list_releases"]
  fn unsafe_list_releases() -> undefined;

  #[link_name = "get_release_info"]
  fn unsafe_get_release_info(release_id: u32) -> undefined;

  #[link_name = "download_release"]
  fn unsafe_download_release(release_id: u32) -> ReleaseError;

  #[link_name = "delete_release"]
  fn unsafe_delete_release(release_id: u32) -> ReleaseError;

  #[link_name = "write_live_release"]
  fn unsafe_write_live_release(buffer: undefined) -> ReleaseError;

  #[link_name = "load_application"]
  fn unsafe_load_application(release_id: u32) -> ReleaseError;

  #[link_name = "stop_application"]
  fn unsafe_stop_application() -> ReleaseError;

  #[link_name = "get_application_state"]
  fn unsafe_get_application_state() -> AppState;

  #[link_name = "get_current_release_id"]
  fn unsafe_get_current_release_id() -> u32;

  #[link_name = "get_storage_total"]
  fn unsafe_get_storage_total() -> u32;

  #[link_name = "get_storage_used"]
  fn unsafe_get_storage_used() -> u32;

  #[link_name = "clean_old_releases"]
  fn unsafe_clean_old_releases(keep_count: u32) -> ReleaseError;
}

pub fn list_releases() -> undefined {
  unsafe {
    return unsafe_list_releases();
  }
}


pub fn get_release_info(release_id: u32) -> undefined {
  unsafe {
    return unsafe_get_release_info(release_id);
  }
}


pub fn download_release(release_id: u32) -> ReleaseError {
  unsafe {
    return unsafe_download_release(release_id);
  }
}


pub fn delete_release(release_id: u32) -> ReleaseError {
  unsafe {
    return unsafe_delete_release(release_id);
  }
}


pub fn write_live_release(buffer: undefined) -> ReleaseError {
  unsafe {
    return unsafe_write_live_release(buffer);
  }
}


pub fn load_application(release_id: u32) -> ReleaseError {
  unsafe {
    return unsafe_load_application(release_id);
  }
}


pub fn stop_application() -> ReleaseError {
  unsafe {
    return unsafe_stop_application();
  }
}


pub fn get_application_state() -> AppState {
  unsafe {
    return unsafe_get_application_state();
  }
}


pub fn get_current_release_id() -> u32 {
  unsafe {
    return unsafe_get_current_release_id();
  }
}


pub fn get_storage_total() -> u32 {
  unsafe {
    return unsafe_get_storage_total();
  }
}


pub fn get_storage_used() -> u32 {
  unsafe {
    return unsafe_get_storage_used();
  }
}


pub fn clean_old_releases(keep_count: u32) -> ReleaseError {
  unsafe {
    return unsafe_clean_old_releases(keep_count);
  }
}

TinyGo

package release

type AppState uint32
const (
  Stopped AppState = 0
  Running AppState = 1
  Crashed AppState = 2
)
type ReleaseError uint32
const (
  Ok ReleaseError = 0
  NotFound ReleaseError = 1
  DownloadFailed ReleaseError = 2
  FileError ReleaseError = 3
  MemoryError ReleaseError = 4
  AlreadyRunning ReleaseError = 5
  AlreadyStopped ReleaseError = 6
  InvalidWasm ReleaseError = 7
)


//go:wasmimport release list_releases
func ListReleases() undefined;

//go:wasmimport release get_release_info
func GetReleaseInfo(ReleaseId uint32) undefined;

//go:wasmimport release download_release
func DownloadRelease(ReleaseId uint32) uint32;

//go:wasmimport release delete_release
func DeleteRelease(ReleaseId uint32) uint32;

//go:wasmimport release write_live_release
func WriteLiveRelease(Buffer undefined) uint32;

//go:wasmimport release load_application
func LoadApplication(ReleaseId uint32) uint32;

//go:wasmimport release stop_application
func StopApplication() uint32;

//go:wasmimport release get_application_state
func GetApplicationState() uint32;

//go:wasmimport release get_current_release_id
func GetCurrentReleaseId() uint32;

//go:wasmimport release get_storage_total
func GetStorageTotal() uint32;

//go:wasmimport release get_storage_used
func GetStorageUsed() uint32;

//go:wasmimport release clean_old_releases
func CleanOldReleases(KeepCount uint32) uint32;

C

typedef enum {
  APP_STATE_STOPPED,
  APP_STATE_RUNNING,
  APP_STATE_CRASHED
} app_state_t;

typedef enum {
  RELEASE_ERROR_OK,
  RELEASE_ERROR_NOT_FOUND,
  RELEASE_ERROR_DOWNLOAD_FAILED,
  RELEASE_ERROR_FILE_ERROR,
  RELEASE_ERROR_MEMORY_ERROR,
  RELEASE_ERROR_ALREADY_RUNNING,
  RELEASE_ERROR_ALREADY_STOPPED,
  RELEASE_ERROR_INVALID_WASM
} release_error_t;


__attribute__((import_module("release")))
__attribute__((import_name("list_releases")))
extern undefined list_releases();


__attribute__((import_module("release")))
__attribute__((import_name("get_release_info")))
extern undefined get_release_info(unsigned int release_id);


__attribute__((import_module("release")))
__attribute__((import_name("download_release")))
extern release_error_t download_release(unsigned int release_id);


__attribute__((import_module("release")))
__attribute__((import_name("delete_release")))
extern release_error_t delete_release(unsigned int release_id);


__attribute__((import_module("release")))
__attribute__((import_name("write_live_release")))
extern release_error_t write_live_release(undefined buffer);


__attribute__((import_module("release")))
__attribute__((import_name("load_application")))
extern release_error_t load_application(unsigned int release_id);


__attribute__((import_module("release")))
__attribute__((import_name("stop_application")))
extern release_error_t stop_application();


__attribute__((import_module("release")))
__attribute__((import_name("get_application_state")))
extern app_state_t get_application_state();


__attribute__((import_module("release")))
__attribute__((import_name("get_current_release_id")))
extern unsigned int get_current_release_id();


__attribute__((import_module("release")))
__attribute__((import_name("get_storage_total")))
extern unsigned int get_storage_total();


__attribute__((import_module("release")))
__attribute__((import_name("get_storage_used")))
extern unsigned int get_storage_used();


__attribute__((import_module("release")))
__attribute__((import_name("clean_old_releases")))
extern release_error_t clean_old_releases(unsigned int keep_count);

C++

typedef enum {
  APP_STATE_STOPPED,
  APP_STATE_RUNNING,
  APP_STATE_CRASHED
} app_state_t;

typedef enum {
  RELEASE_ERROR_OK,
  RELEASE_ERROR_NOT_FOUND,
  RELEASE_ERROR_DOWNLOAD_FAILED,
  RELEASE_ERROR_FILE_ERROR,
  RELEASE_ERROR_MEMORY_ERROR,
  RELEASE_ERROR_ALREADY_RUNNING,
  RELEASE_ERROR_ALREADY_STOPPED,
  RELEASE_ERROR_INVALID_WASM
} release_error_t;

extern "C" {
  __attribute__((import_module("release")))
  __attribute__((import_name("list_releases")))
  extern undefined list_releases();

  __attribute__((import_module("release")))
  __attribute__((import_name("get_release_info")))
  extern undefined get_release_info(unsigned int release_id);

  __attribute__((import_module("release")))
  __attribute__((import_name("download_release")))
  extern release_error_t download_release(unsigned int release_id);

  __attribute__((import_module("release")))
  __attribute__((import_name("delete_release")))
  extern release_error_t delete_release(unsigned int release_id);

  __attribute__((import_module("release")))
  __attribute__((import_name("write_live_release")))
  extern release_error_t write_live_release(undefined buffer);

  __attribute__((import_module("release")))
  __attribute__((import_name("load_application")))
  extern release_error_t load_application(unsigned int release_id);

  __attribute__((import_module("release")))
  __attribute__((import_name("stop_application")))
  extern release_error_t stop_application();

  __attribute__((import_module("release")))
  __attribute__((import_name("get_application_state")))
  extern app_state_t get_application_state();

  __attribute__((import_module("release")))
  __attribute__((import_name("get_current_release_id")))
  extern unsigned int get_current_release_id();

  __attribute__((import_module("release")))
  __attribute__((import_name("get_storage_total")))
  extern unsigned int get_storage_total();

  __attribute__((import_module("release")))
  __attribute__((import_name("get_storage_used")))
  extern unsigned int get_storage_used();

  __attribute__((import_module("release")))
  __attribute__((import_name("clean_old_releases")))
  extern release_error_t clean_old_releases(unsigned int keep_count);
}