gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Cleanup features and fix build errors

Browse Source
This commit is contained in:
Michael Vines
2019-03-02 21:33:02 -08:00
committed by Grimes
parent 534619f72f
commit 109101c2dc
3 changed files with 137 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -2035,6 +2035,7 @@ dependencies = [
"solana-bpfloader 0.12.0", "solana-bpfloader 0.12.0",
"solana-logger 0.12.0", "solana-logger 0.12.0",
"solana-native-loader 0.12.0", "solana-native-loader 0.12.0",
"solana-runtime 0.12.0",
"solana-sdk 0.12.0", "solana-sdk 0.12.0",
] ]

1
programs/bpf/Cargo.toml
View File

@ -22,4 +22,5 @@ solana = { path = "../../core", version = "0.12.0" }
solana-bpfloader = { path = "../bpf_loader", version = "0.12.0" } solana-bpfloader = { path = "../bpf_loader", version = "0.12.0" }
solana-logger = { path = "../../logger", version = "0.12.0" } solana-logger = { path = "../../logger", version = "0.12.0" }
solana-native-loader = { path = "../native_loader", version = "0.12.0" } solana-native-loader = { path = "../native_loader", version = "0.12.0" }
solana-runtime = { path = "../../runtime", version = "0.12.0" }
solana-sdk = { path = "../../sdk", version = "0.12.0" } solana-sdk = { path = "../../sdk", version = "0.12.0" }

259
programs/bpf/tests/programs.rs
View File

@ -1,137 +1,148 @@
#[cfg(feature = "bpf_c")]
use solana_sdk::bpf_loader;
#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))] #[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
use std::env; mod bpf {
#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))] use solana_runtime::bank::Bank;
use std::fs::File; use solana_runtime::loader_utils::load_program;
#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))] use solana_sdk::genesis_block::GenesisBlock;
use std::io::Read; use solana_sdk::native_loader;
#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))] use solana_sdk::transaction::Transaction;
use std::path::PathBuf; use std::env;
use std::fs::File;
use std::path::PathBuf;
/// BPF program file extension /// BPF program file extension
#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))] const PLATFORM_FILE_EXTENSION_BPF: &str = "so";
const PLATFORM_FILE_EXTENSION_BPF: &str = "so";
/// Create a BPF program file name
#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
fn create_bpf_path(name: &str) -> PathBuf {
let mut pathbuf = {
let current_exe = env::current_exe().unwrap();
PathBuf::from(current_exe.parent().unwrap().parent().unwrap())
};
pathbuf.push("bpf/");
pathbuf.push(name);
pathbuf.set_extension(PLATFORM_FILE_EXTENSION_BPF);
pathbuf
}
#[cfg(feature = "bpf_c")] /// Create a BPF program file name
#[test] fn create_bpf_path(name: &str) -> PathBuf {
fn test_program_bpf_c_noop() { let mut pathbuf = {
solana_logger::setup(); let current_exe = env::current_exe().unwrap();
PathBuf::from(current_exe.parent().unwrap().parent().unwrap())
};
pathbuf.push("bpf/");
pathbuf.push(name);
pathbuf.set_extension(PLATFORM_FILE_EXTENSION_BPF);
pathbuf
}
let mut file = File::open(create_bpf_path("noop")).expect("file open failed"); #[cfg(feature = "bpf_c")]
let mut elf = Vec::new(); mod bpf_c {
file.read_to_end(&mut elf).unwrap(); use super::*;
use solana_sdk::bpf_loader;
use std::io::Read;
let (genesis_block, mint_keypair) = GenesisBlock::new(50); #[test]
let bank = Bank::new(&genesis_block); fn test_program_bpf_c_noop() {
solana_logger::setup();
// Call user program let mut file = File::open(create_bpf_path("noop")).expect("file open failed");
let program_id = load_program(&bank, &mint_keypair, bpf_loader::id(), elf); let mut elf = Vec::new();
let tx = Transaction::new( file.read_to_end(&mut elf).unwrap();
&mint_keypair,
&[],
program_id,
&vec![1u8],
bank.last_blockhash(),
0,
);
bank.process_transaction(&tx).unwrap();
assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
}
#[cfg(feature = "bpf_c")] let (genesis_block, mint_keypair) = GenesisBlock::new(50);
#[test] let bank = Bank::new(&genesis_block);
fn test_program_bpf_c() {
solana_logger::setup();
let programs = [ // Call user program
"bpf_to_bpf", let program_id = load_program(&bank, &mint_keypair, bpf_loader::id(), elf);
"multiple_static", let tx = Transaction::new(
"noop", &mint_keypair,
"noop++", &[],
"relative_call", program_id,
"struct_pass", &vec![1u8],
"struct_ret", bank.last_blockhash(),
]; 0,
for program in programs.iter() { );
println!("Test program: {:?}", program); bank.process_transaction(&tx).unwrap();
let mut file = File::open(create_bpf_path(program)).expect("file open failed"); assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
let mut elf = Vec::new(); }
file.read_to_end(&mut elf).unwrap();
let (genesis_block, mint_keypair) = GenesisBlock::new(50); #[test]
let bank = Bank::new(&genesis_block); fn test_program_bpf_c() {
solana_logger::setup();
let loader_id = load_program( let programs = [
&bank, "bpf_to_bpf",
&mint_keypair, "multiple_static",
native_loader::id(), "noop",
"solana_bpf_loader".as_bytes().to_vec(), "noop++",
); "relative_call",
"struct_pass",
"struct_ret",
];
for program in programs.iter() {
println!("Test program: {:?}", program);
let mut file = File::open(create_bpf_path(program)).expect("file open failed");
let mut elf = Vec::new();
file.read_to_end(&mut elf).unwrap();
// Call user program let (genesis_block, mint_keypair) = GenesisBlock::new(50);
let program_id = load_program(&bank, &mint_keypair, loader_id, elf); let bank = Bank::new(&genesis_block);
let tx = Transaction::new(
&mint_keypair, let loader_id = load_program(
&[], &bank,
program_id, &mint_keypair,
&vec![1u8], native_loader::id(),
bank.last_blockhash(), "solana_bpf_loader".as_bytes().to_vec(),
0, );
);
bank.process_transaction(&tx).unwrap(); // Call user program
assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(()))); let program_id = load_program(&bank, &mint_keypair, loader_id, elf);
} let tx = Transaction::new(
} &mint_keypair,
&[],
// Cannot currently build the Rust BPF program as part program_id,
// of the rest of the build due to recursive `cargo build` causing &vec![1u8],
// a build deadlock. Therefore you must build the Rust programs bank.last_blockhash(),
// yourself first by calling `make all` in the Rust BPF program's directory 0,
#[cfg(feature = "bpf_rust")] );
#[test] bank.process_transaction(&tx).unwrap();
fn test_program_bpf_rust() { assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
solana_logger::setup(); }
}
let programs = ["solana_bpf_rust_noop"]; }
for program in programs.iter() {
println!("Test program: {:?}", program); // Cannot currently build the Rust BPF program as part
let mut file = File::open(create_bpf_path(program)).expect("file open failed"); // of the rest of the build due to recursive `cargo build` causing
let mut elf = Vec::new(); // a build deadlock. Therefore you must build the Rust programs
file.read_to_end(&mut elf).unwrap(); // yourself first by calling `make all` in the Rust BPF program's directory
#[cfg(feature = "bpf_rust")]
let (genesis_block, mint_keypair) = GenesisBlock::new(50); mod bpf_rust {
let bank = Bank::new(&genesis_block); use super::*;
let loader_id = load_program( use std::io::Read;
&bank,
&mint_keypair, #[test]
native_loader::id(), fn test_program_bpf_rust() {
"solana_bpf_loader".as_bytes().to_vec(), solana_logger::setup();
);
let programs = ["solana_bpf_rust_noop"];
// Call user program for program in programs.iter() {
let program_id = load_program(&bank, &mint_keypair, loader_id, elf); let filename = create_bpf_path(program);
let tx = Transaction::new( println!("Test program: {:?} from {:?}", program, filename);
&mint_keypair, let mut file = File::open(filename).unwrap();
&[], let mut elf = Vec::new();
program_id, file.read_to_end(&mut elf).unwrap();
&vec![1u8],
bank.last_blockhash(), let (genesis_block, mint_keypair) = GenesisBlock::new(50);
0, let bank = Bank::new(&genesis_block);
); let loader_id = load_program(
bank.process_transaction(&tx).unwrap(); &bank,
assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(()))); &mint_keypair,
native_loader::id(),
"solana_bpf_loader".as_bytes().to_vec(),
);
// Call user program
let program_id = load_program(&bank, &mint_keypair, loader_id, elf);
let tx = Transaction::new(
&mint_keypair,
&[],
program_id,
&vec![1u8],
bank.last_blockhash(),
0,
);
bank.process_transaction(&tx).unwrap();
assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
}
}
} }
} }